diff options
Diffstat (limited to 'src')
365 files changed, 2760 insertions, 2759 deletions
diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs index 87ec11c876e..a0d52bb9fd5 100644 --- a/src/cargo/cargo.rs +++ b/src/cargo/cargo.rs @@ -369,7 +369,7 @@ fn rest(s: ~str, start: uint) -> ~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]; + fail fmt!{"can't make_dir %s", s}; } } @@ -387,7 +387,7 @@ fn valid_pkg_name(s: ~str) -> bool { fn parse_source(name: ~str, j: json::json) -> source { if !valid_pkg_name(name) { - fail #fmt("'%s' is an invalid source name", name); + fail fmt!{"'%s' is an invalid source name", name}; } alt j { @@ -438,11 +438,11 @@ fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) { ok(json::dict(j)) { for j.each |k, v| { sources.insert(k, parse_source(k, v)); - #debug("source: %s", k); + debug!{"source: %s", k}; } } ok(_) { fail ~"malformed sources.json"; } - err(e) { fail #fmt("%s:%s", filename, e.to_str()); } + err(e) { fail fmt!{"%s:%s", filename, e.to_str()}; } } } @@ -565,7 +565,7 @@ fn load_source_info(c: cargo, src: source) { ~"(source info is not a dict)"); } err(e) { - warn(#fmt("%s:%s", src.name, e.to_str())); + warn(fmt!{"%s:%s", src.name, e.to_str()}); } }; } @@ -594,7 +594,7 @@ fn load_source_packages(c: cargo, src: source) { ~"(packages is not a list)"); } err(e) { - warn(#fmt("%s:%s", src.name, e.to_str())); + warn(fmt!{"%s:%s", src.name, e.to_str()}); } }; } @@ -603,7 +603,7 @@ fn build_cargo_options(argv: ~[~str]) -> options { let match = alt getopts::getopts(argv, opts()) { result::ok(m) { m } result::err(f) { - fail #fmt["%s", getopts::fail_str(f)]; + fail fmt!{"%s", getopts::fail_str(f)}; } }; @@ -713,11 +713,11 @@ 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); + debug!{"%s: %s -> %s", what, cf, buildpath}; let p = run::program_output(rustc_sysroot(), ~[~"--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]); + error(fmt!{"rustc failed: %d\n%s\n%s", p.status, p.err, p.out}); ret none; } some(buildpath) @@ -744,7 +744,7 @@ fn install_one_crate(c: cargo, path: ~str, cf: ~str) { if (exec_suffix != ~"" && str::ends_with(ct, exec_suffix)) || (exec_suffix == ~"" && !str::starts_with(path::basename(ct), ~"lib")) { - #debug(" bin: %s", ct); + debug!{" bin: %s", ct}; install_to_dir(ct, c.bindir); if c.opts.mode == system_mode { // FIXME (#2662): Put this file in PATH / symlink it so it can @@ -752,7 +752,7 @@ fn install_one_crate(c: cargo, path: ~str, cf: ~str) { // `cargo install -G rustray` and `rustray file.obj` } } else { - #debug(" lib: %s", ct); + debug!{" lib: %s", ct}; install_to_dir(ct, c.libdir); } } @@ -764,7 +764,7 @@ fn rustc_sysroot() -> ~str { some(path) { let path = ~[path, ~"..", ~"bin", ~"rustc"]; let rustc = path::normalize(path::connect_many(path)); - #debug(" rustc: %s", rustc); + debug!{" rustc: %s", rustc}; rustc } none { ~"rustc" } @@ -772,7 +772,7 @@ fn rustc_sysroot() -> ~str { } fn install_source(c: cargo, path: ~str) { - #debug("source: %s", path); + debug!{"source: %s", path}; os::change_dir(path); let mut cratefiles = ~[]; @@ -798,7 +798,7 @@ fn install_source(c: cargo, path: ~str) { let wd_base = c.workdir + path::path_sep(); let wd = alt tempfile::mkdtemp(wd_base, ~"") { some(wd) { wd } - none { fail #fmt("needed temp dir: %s", wd_base); } + none { fail fmt!{"needed temp dir: %s", wd_base}; } }; install_query(c, wd, query); @@ -831,7 +831,7 @@ fn install_curl(c: cargo, wd: ~str, url: ~str) { 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]; + fail fmt!{"fetch of %s failed: %s", url, p.err}; } run::run_program(~"tar", ~[~"-x", ~"--strip-components=1", ~"-C", wd, ~"-f", tarpath]); @@ -852,7 +852,7 @@ fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) { _ { ~"curl" } }; - info(#fmt["installing %s/%s via %s...", src, pkg.name, method]); + info(fmt!{"installing %s/%s via %s...", src, pkg.name, method}); alt method { ~"git" { install_git(c, wd, url, copy pkg.ref); } @@ -1082,7 +1082,7 @@ fn cmd_install(c: cargo) unsafe { let wd_base = c.workdir + path::path_sep(); let wd = alt tempfile::mkdtemp(wd_base, ~"") { some(wd) { wd } - none { fail #fmt("needed temp dir: %s", wd_base); } + none { fail fmt!{"needed temp dir: %s", wd_base}; } }; if vec::len(c.opts.free) == 2u { @@ -1090,7 +1090,7 @@ fn cmd_install(c: cargo) unsafe { let status = run::run_program(~"cp", ~[~"-R", cwd, wd]); if status != 0 { - fail #fmt("could not copy directory: %s", cwd); + fail fmt!{"could not copy directory: %s", cwd}; } install_source(c, wd); @@ -1126,7 +1126,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { let mut has_src_file = false; if !os::copy_file(path::connect(url, ~"packages.json"), pkgfile) { - error(#fmt["fetch for source %s (url %s) failed", name, url]); + error(fmt!{"fetch for source %s (url %s) failed", name, url}); ret false; } @@ -1142,7 +1142,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { 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]); + error(fmt!{"fetch for source %s (key %s) failed", name, u}); ret false; } pgp::add(c.root, keyfile); @@ -1154,8 +1154,8 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { let r = pgp::verify(c.root, pkgfile, sigfile, f); if !r { - error(#fmt["signature verification failed for source %s", - name]); + error(fmt!{"signature verification failed for source %s", + name}); ret false; } @@ -1163,8 +1163,8 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { let e = pgp::verify(c.root, srcfile, srcsigfile, f); if !e { - error(#fmt["signature verification failed for source %s", - name]); + error(fmt!{"signature verification failed for source %s", + name}); ret false; } } @@ -1184,7 +1184,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { os::remove_file(pkgfile); os::remove_file(sigfile); - info(#fmt["synced source: %s", name]); + info(fmt!{"synced source: %s", name}); ret true; } @@ -1200,7 +1200,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { fn rollback(name: ~str, dir: ~str, insecure: bool) { fn msg(name: ~str, insecure: bool) { - error(#fmt["could not rollback source: %s", name]); + error(fmt!{"could not rollback source: %s", name}); if insecure { warn(~"a past security check failed on source " + @@ -1226,20 +1226,20 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { let p = run::program_output(~"git", ~[~"clone", url, dir]); if p.status != 0 { - error(#fmt["fetch for source %s (url %s) failed", name, url]); + error(fmt!{"fetch for source %s (url %s) failed", name, url}); ret false; } } else { if !os::change_dir(dir) { - error(#fmt["fetch for source %s (url %s) failed", name, url]); + error(fmt!{"fetch for source %s (url %s) failed", name, url}); ret false; } let p = run::program_output(~"git", ~[~"pull"]); if p.status != 0 { - error(#fmt["fetch for source %s (url %s) failed", name, url]); + error(fmt!{"fetch for source %s (url %s) failed", name, url}); ret false; } } @@ -1251,7 +1251,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { 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]); + error(fmt!{"fetch for source %s (key %s) failed", name, u}); rollback(name, dir, false); ret false; } @@ -1264,8 +1264,8 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { let r = pgp::verify(c.root, pkgfile, sigfile, f); if !r { - error(#fmt["signature verification failed for source %s", - name]); + error(fmt!{"signature verification failed for source %s", + name}); rollback(name, dir, false); ret false; } @@ -1274,8 +1274,8 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { let e = pgp::verify(c.root, srcfile, srcsigfile, f); if !e { - error(#fmt["signature verification failed for source %s", - name]); + error(fmt!{"signature verification failed for source %s", + name}); rollback(name, dir, false); ret false; } @@ -1286,7 +1286,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { os::remove_file(keyfile); - info(#fmt["synced source: %s", name]); + info(fmt!{"synced source: %s", name}); ret true; } @@ -1312,7 +1312,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { ~[~"-f", ~"-s", ~"-o", pkgfile, url]); if p.status != 0 { - error(#fmt["fetch for source %s (url %s) failed", name, url]); + error(fmt!{"fetch for source %s (url %s) failed", name, url}); ret false; } if smart { @@ -1331,7 +1331,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { 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]); + error(fmt!{"fetch for source %s (key %s) failed", name, u}); ret false; } pgp::add(c.root, keyfile); @@ -1350,15 +1350,15 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { 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]); + error(fmt!{"fetch for source %s (sig %s) failed", name, url}); ret false; } let r = pgp::verify(c.root, pkgfile, sigfile, f); if !r { - error(#fmt["signature verification failed for source %s", - name]); + error(fmt!{"signature verification failed for source %s", + name}); ret false; } @@ -1369,8 +1369,8 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { ~[~"-f", ~"-s", ~"-o", srcsigfile, url]); if p.status != 0 { - error(#fmt["fetch for source %s (sig %s) failed", - name, url]); + error(fmt!{"fetch for source %s (sig %s) failed", + name, url}); ret false; } @@ -1398,7 +1398,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { os::remove_file(pkgfile); os::remove_file(sigfile); - info(#fmt["synced source: %s", name]); + info(fmt!{"synced source: %s", name}); ret true; } @@ -1407,7 +1407,7 @@ fn sync_one(c: cargo, src: source) { let name = src.name; let dir = path::connect(c.sourcedir, name); - info(#fmt["syncing source: %s...", name]); + info(fmt!{"syncing source: %s...", name}); need_dir(dir); @@ -1434,20 +1434,20 @@ fn cmd_init(c: cargo) { let p = run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", srcfile, srcurl]); if p.status != 0 { - error(#fmt["fetch of sources.json failed: %s", p.out]); + error(fmt!{"fetch of sources.json failed: %s", p.out}); ret; } let p = run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", sigfile, sigurl]); if p.status != 0 { - error(#fmt["fetch of sources.json.sig failed: %s", p.out]); + error(fmt!{"fetch of sources.json.sig failed: %s", p.out}); ret; } let r = pgp::verify(c.root, srcfile, sigfile, pgp::signing_key_fp()); if !r { - error(#fmt["signature verification failed for '%s'", srcfile]); + error(fmt!{"signature verification failed for '%s'", srcfile}); ret; } @@ -1455,7 +1455,7 @@ fn cmd_init(c: cargo) { os::remove_file(srcfile); os::remove_file(sigfile); - info(#fmt["initialized .cargo in %s", c.root]); + info(fmt!{"initialized .cargo in %s", c.root}); } fn print_pkg(s: source, p: package) { @@ -1496,14 +1496,14 @@ fn cmd_list(c: cargo) { if vec::len(c.opts.free) >= 3u { do vec::iter_between(c.opts.free, 2u, vec::len(c.opts.free)) |name| { if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); } else { alt c.sources.find(name) { some(source) { print_source(source); } none { - error(#fmt("no such source: %s", name)); + error(fmt!{"no such source: %s", name}); } } } @@ -1533,7 +1533,7 @@ fn cmd_search(c: cargo) { n += 1; } }); - info(#fmt["found %d packages", n]); + info(fmt!{"found %d packages", n}); } fn install_to_dir(srcfile: ~str, destdir: ~str) { @@ -1541,9 +1541,9 @@ fn install_to_dir(srcfile: ~str, destdir: ~str) { let status = run::run_program(~"cp", ~[~"-r", srcfile, newfile]); if status == 0 { - info(#fmt["installed: '%s'", newfile]); + info(fmt!{"installed: '%s'", newfile}); } else { - error(#fmt["could not install: '%s'", newfile]); + error(fmt!{"could not install: '%s'", newfile}); } } @@ -1601,22 +1601,22 @@ fn dump_sources(c: cargo) { writer.write_str(json::to_str(root)); } result::err(e) { - error(#fmt("could not dump sources: %s", e)); + error(fmt!{"could not dump sources: %s", e}); } } } fn copy_warn(srcfile: ~str, destfile: ~str) { if !os::copy_file(srcfile, destfile) { - warn(#fmt["copying %s to %s failed", srcfile, destfile]); + warn(fmt!{"copying %s to %s failed", srcfile, destfile}); } } fn cmd_sources(c: cargo) { if vec::len(c.opts.free) < 3u { for c.sources.each_value |v| { - info(#fmt("%s (%s) via %s", - v.name, v.url, v.method)); + info(fmt!{"%s (%s) via %s", + v.name, v.url, v.method}); } ret; } @@ -1641,13 +1641,13 @@ fn cmd_sources(c: cargo) { let url = c.opts.free[4u]; if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); ret; } alt c.sources.find(name) { some(source) { - error(#fmt("source already exists: %s", name)); + error(fmt!{"source already exists: %s", name}); } none { c.sources.insert(name, @{ @@ -1658,7 +1658,7 @@ fn cmd_sources(c: cargo) { mut keyfp: none, mut packages: ~[mut] }); - info(#fmt("added source: %s", name)); + info(fmt!{"added source: %s", name}); } } } @@ -1671,17 +1671,17 @@ fn cmd_sources(c: cargo) { let name = c.opts.free[3u]; if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); ret; } alt c.sources.find(name) { some(source) { c.sources.remove(name); - info(#fmt("removed source: %s", name)); + info(fmt!{"removed source: %s", name}); } none { - error(#fmt("no such source: %s", name)); + error(fmt!{"no such source: %s", name}); } } } @@ -1695,7 +1695,7 @@ fn cmd_sources(c: cargo) { let url = c.opts.free[4u]; if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); ret; } @@ -1709,10 +1709,10 @@ fn cmd_sources(c: cargo) { c.sources.insert(name, source); - info(#fmt("changed source url: '%s' to '%s'", old, url)); + info(fmt!{"changed source url: '%s' to '%s'", old, url}); } none { - error(#fmt("no such source: %s", name)); + error(fmt!{"no such source: %s", name}); } } } @@ -1726,7 +1726,7 @@ fn cmd_sources(c: cargo) { let method = c.opts.free[4u]; if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); ret; } @@ -1742,11 +1742,11 @@ fn cmd_sources(c: cargo) { c.sources.insert(name, source); - info(#fmt("changed source method: '%s' to '%s'", old, - method)); + info(fmt!{"changed source method: '%s' to '%s'", old, + method}); } none { - error(#fmt("no such source: %s", name)); + error(fmt!{"no such source: %s", name}); } } } @@ -1760,11 +1760,11 @@ fn cmd_sources(c: cargo) { let newn = c.opts.free[4u]; if !valid_pkg_name(name) { - error(#fmt("'%s' is an invalid source name", name)); + error(fmt!{"'%s' is an invalid source name", name}); ret; } if !valid_pkg_name(newn) { - error(#fmt("'%s' is an invalid source name", newn)); + error(fmt!{"'%s' is an invalid source name", newn}); ret; } @@ -1772,10 +1772,10 @@ fn cmd_sources(c: cargo) { some(source) { c.sources.remove(name); c.sources.insert(newn, source); - info(#fmt("renamed source: %s to %s", name, newn)); + info(fmt!{"renamed source: %s to %s", name, newn}); } none { - error(#fmt("no such source: %s", name)); + error(fmt!{"no such source: %s", name}); } } } diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 3ba358bfb93..066b9c78ee9 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -68,20 +68,20 @@ fn parse_config(args: ~[~str]) -> config { fn log_config(config: config) { let c = config; - logv(c, #fmt["configuration:"]); - logv(c, #fmt["compile_lib_path: %s", config.compile_lib_path]); - logv(c, #fmt["run_lib_path: %s", config.run_lib_path]); - logv(c, #fmt["rustc_path: %s", config.rustc_path]); - logv(c, #fmt["src_base: %s", config.src_base]); - logv(c, #fmt["build_base: %s", config.build_base]); - logv(c, #fmt["stage_id: %s", config.stage_id]); - logv(c, #fmt["mode: %s", mode_str(config.mode)]); - logv(c, #fmt["run_ignored: %b", config.run_ignored]); - logv(c, #fmt["filter: %s", opt_str(config.filter)]); - logv(c, #fmt["runtool: %s", opt_str(config.runtool)]); - logv(c, #fmt["rustcflags: %s", opt_str(config.rustcflags)]); - logv(c, #fmt["verbose: %b", config.verbose]); - logv(c, #fmt["\n"]); + logv(c, fmt!{"configuration:"}); + logv(c, fmt!{"compile_lib_path: %s", config.compile_lib_path}); + logv(c, fmt!{"run_lib_path: %s", config.run_lib_path}); + logv(c, fmt!{"rustc_path: %s", config.rustc_path}); + logv(c, fmt!{"src_base: %s", config.src_base}); + logv(c, fmt!{"build_base: %s", config.build_base}); + logv(c, fmt!{"stage_id: %s", config.stage_id}); + logv(c, fmt!{"mode: %s", mode_str(config.mode)}); + logv(c, fmt!{"run_ignored: %b", config.run_ignored}); + logv(c, fmt!{"filter: %s", opt_str(config.filter)}); + logv(c, fmt!{"runtool: %s", opt_str(config.runtool)}); + logv(c, fmt!{"rustcflags: %s", opt_str(config.rustcflags)}); + logv(c, fmt!{"verbose: %b", config.verbose}); + logv(c, fmt!{"\n"}); } fn opt_str(maybestr: option<~str>) -> ~str { @@ -134,11 +134,11 @@ fn test_opts(config: config) -> test::test_opts { } fn make_tests(config: config) -> ~[test::test_desc] { - #debug("making tests from %s", config.src_base); + debug!{"making tests from %s", config.src_base}; let mut tests = ~[]; for os::list_dir_path(config.src_base).each |file| { let file = file; - #debug("inspecting file %s", file); + debug!{"inspecting file %s", file}; if is_test(config, file) { vec::push(tests, make_test(config, file)) } @@ -177,7 +177,7 @@ fn make_test(config: config, testfile: ~str) -> } fn make_test_name(config: config, testfile: ~str) -> ~str { - #fmt["[%s] %s", mode_str(config.mode), testfile] + fmt!{"[%s] %s", mode_str(config.mode), testfile} } fn make_test_closure(config: config, testfile: ~str) -> test::test_fn { diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index 64e36cb1f5e..e44c80e79b9 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -47,7 +47,7 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe { while idx < len && line[idx] == (' ' as u8) { idx += 1u; } let msg = str::slice(line, idx, len); - #debug("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg); + debug!{"line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg}; ret ~[{line: line_num - adjust_line, kind: kind, msg: msg}]; } diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 0d90f1435b9..c5101174424 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -110,7 +110,7 @@ fn parse_exec_env(line: ~str) -> option<(~str, ~str)> { alt strs.len() { 1u { (strs[0], ~"") } 2u { (strs[0], strs[1]) } - n { fail #fmt["Expected 1 or 2 strings, not %u", n]; } + n { fail fmt!{"Expected 1 or 2 strings, not %u", n}; } } } } @@ -139,7 +139,7 @@ fn parse_name_value_directive(line: ~str, option::some(colon) { let value = str::slice(line, colon + str::len(keycolon), str::len(line)); - #debug("%s: %s", directive, value); + debug!{"%s: %s", directive, value}; option::some(value) } option::none { option::none } diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index d5890031109..e708af2d6a3 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -16,7 +16,7 @@ fn run(config: config, testfile: ~str) { // We're going to be dumping a lot of info. Start on a new line. io::stdout().write_str(~"\n\n"); } - #debug("running %s", testfile); + debug!{"running %s", testfile}; let props = load_props(testfile); alt config.mode { mode_compile_fail { run_cfail_test(config, props, testfile); } @@ -68,8 +68,8 @@ fn check_correct_failure_status(procres: procres) { const rust_err: int = 101; if procres.status != rust_err { fatal_procres( - #fmt("failure produced the wrong error code: %d", - procres.status), + fmt!{"failure produced the wrong error code: %d", + procres.status}, procres); } } @@ -96,11 +96,11 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) { let mut round = 0; while round < rounds { - logv(config, #fmt["pretty-printing round %d", round]); + logv(config, fmt!{"pretty-printing round %d", round}); let procres = print_source(config, testfile, srcs[round]); if procres.status != 0 { - fatal_procres(#fmt["pretty-printing failed in round %d", round], + fatal_procres(fmt!{"pretty-printing failed in round %d", round}, procres); } @@ -151,7 +151,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) { if expected != actual { error(~"pretty-printed source does not match expected source"); let msg = - #fmt["\n\ + fmt!{"\n\ expected:\n\ ------------------------------------------\n\ %s\n\ @@ -161,7 +161,7 @@ actual:\n\ %s\n\ ------------------------------------------\n\ \n", - expected, actual]; + expected, actual}; io::stdout().write_str(msg); fail; } @@ -201,10 +201,10 @@ fn check_error_patterns(props: test_props, let mut done = false; for str::split_char(procres.stderr, '\n').each |line| { if str::contains(line, next_err_pat) { - #debug("found error pattern %s", next_err_pat); + debug!{"found error pattern %s", next_err_pat}; next_err_idx += 1u; if next_err_idx == vec::len(props.error_patterns) { - #debug("found all error patterns"); + debug!{"found all error patterns"}; done = true; break; } @@ -217,11 +217,11 @@ fn check_error_patterns(props: test_props, vec::slice(props.error_patterns, next_err_idx, vec::len(props.error_patterns)); if vec::len(missing_patterns) == 1u { - fatal_procres(#fmt["error pattern '%s' not found!", - missing_patterns[0]], procres); + fatal_procres(fmt!{"error pattern '%s' not found!", + missing_patterns[0]}, procres); } else { for missing_patterns.each |pattern| { - error(#fmt["error pattern '%s' not found!", pattern]); + error(fmt!{"error pattern '%s' not found!", pattern}); } fatal_procres(~"multiple error patterns not found", procres); } @@ -240,7 +240,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], } let prefixes = vec::map(expected_errors, |ee| { - #fmt("%s:%u:", testfile, ee.line) + fmt!{"%s:%u:", testfile, ee.line} }); // Scan and extract our error/warning messages, @@ -253,8 +253,8 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], let mut was_expected = false; for vec::eachi(expected_errors) |i, ee| { if !found_flags[i] { - #debug["prefix=%s ee.kind=%s ee.msg=%s line=%s", - prefixes[i], ee.kind, ee.msg, line]; + debug!{"prefix=%s ee.kind=%s ee.msg=%s line=%s", + prefixes[i], ee.kind, ee.msg, line}; if (str::starts_with(line, prefixes[i]) && str::contains(line, ee.kind) && str::contains(line, ee.msg)) { @@ -272,7 +272,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], if !was_expected && (str::contains(line, ~"error") || str::contains(line, ~"warning")) { - fatal_procres(#fmt["unexpected error pattern '%s'!", line], + fatal_procres(fmt!{"unexpected error pattern '%s'!", line}, procres); } } @@ -280,8 +280,8 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], for uint::range(0u, vec::len(found_flags)) |i| { if !found_flags[i] { let ee = expected_errors[i]; - fatal_procres(#fmt["expected %s on line %u not found: %s", - ee.kind, ee.line, ee.msg], procres); + fatal_procres(fmt!{"expected %s on line %u not found: %s", + ee.kind, ee.line, ee.msg}, procres); } } } @@ -330,7 +330,7 @@ fn compose_and_run_compiler( config.compile_lib_path, option::none); if auxres.status != 0 { fatal_procres( - #fmt["auxiliary build of %s failed to compile: ", abs_ab], + fmt!{"auxiliary build of %s failed to compile: ", abs_ab}, auxres); } } @@ -342,7 +342,7 @@ fn compose_and_run_compiler( fn ensure_dir(path: path) { if os::path_is_dir(path) { ret; } if !os::make_dir(path, 0x1c0i32) { - fail #fmt("can't make dir %s", path); + fail fmt!{"can't make dir %s", path}; } } @@ -414,7 +414,7 @@ fn program_output(config: config, testfile: ~str, lib_path: ~str, prog: ~str, let cmdline = { let cmdline = make_cmdline(lib_path, prog, args); - logv(config, #fmt["executing %s", cmdline]); + logv(config, fmt!{"executing %s", cmdline}); cmdline }; let res = procsrv::run(lib_path, prog, args, env, input); @@ -430,19 +430,19 @@ fn program_output(config: config, testfile: ~str, lib_path: ~str, prog: ~str, #[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, ~" ")] + fmt!{"%s %s", prog, str::connect(args, ~" ")} } #[cfg(target_os = "win32")] fn make_cmdline(libpath: ~str, prog: ~str, args: ~[~str]) -> ~str { - #fmt["%s %s %s", lib_path_cmd_prefix(libpath), prog, - str::connect(args, ~" ")] + fmt!{"%s %s %s", lib_path_cmd_prefix(libpath), prog, + str::connect(args, ~" ")} } // 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 { - #fmt["%s=\"%s\"", util::lib_path_env_var(), util::make_new_path(path)] + fmt!{"%s=\"%s\"", util::lib_path_env_var(), util::make_new_path(path)} } fn dump_output(config: config, testfile: ~str, out: ~str, err: ~str) { @@ -475,13 +475,13 @@ fn output_testname(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] + fmt!{"%s%s.%s", base, filename, config.stage_id} } 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 sep1 = fmt!{"------%s------------------------------", ~"stdout"}; + let sep2 = fmt!{"------%s------------------------------", ~"stderr"}; let sep3 = ~"------------------------------------------"; io::stdout().write_line(sep1); io::stdout().write_line(out); @@ -491,13 +491,13 @@ 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_procres(err: ~str, procres: procres) -> ! { let msg = - #fmt["\n\ + fmt!{"\n\ error: %s\n\ command: %s\n\ stdout:\n\ @@ -509,7 +509,7 @@ stderr:\n\ %s\n\ ------------------------------------------\n\ \n", - err, procres.cmdline, procres.stdout, procres.stderr]; + err, procres.cmdline, procres.stdout, procres.stderr}; io::stdout().write_str(msg); fail; } diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index bd99b340138..fec0fc84bc3 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -9,7 +9,7 @@ fn make_new_path(path: ~str) -> ~str { // maintain the current value while adding our own alt getenv(lib_path_env_var()) { option::some(curr) { - #fmt["%s%s%s", path, path_div(), curr] + fmt!{"%s%s%s", path, path_div(), curr} } option::none { path } } diff --git a/src/fuzzer/ast_match.rs b/src/fuzzer/ast_match.rs index 2b995501769..abfcac55534 100644 --- a/src/fuzzer/ast_match.rs +++ b/src/fuzzer/ast_match.rs @@ -26,5 +26,5 @@ fn main() { assert (!vec_equal(~[5, 5], ~[4, 5], builtin_equal_int)); assert (vec_equal(~[5, 5], ~[5, 5], builtin_equal_int)); - #error("Pass"); + error!{"Pass"}; } diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 908dff102f7..ea10ff58049 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -246,8 +246,8 @@ fn check_variants_T<T: copy>( replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate, cx: context ) { - #error("%s contains %u %s objects", filename, - vec::len(things), thing_label); + error!{"%s contains %u %s objects", filename, + vec::len(things), thing_label}; let L = vec::len(things); @@ -277,9 +277,9 @@ fn check_variants_T<T: copy>( check_roundtrip_convergence(str3, 1u); } tm_run { - let file_label = #fmt("rusttmp/%s_%s_%u_%u", + let file_label = fmt!{"rusttmp/%s_%s_%u_%u", last_part(filename), - thing_label, i, j); + thing_label, i, j}; let safe_to_run = !(content_is_dangerous_to_run(*str3) || has_raw_pointers(*crate2)); check_whole_compiler(*str3, file_label, safe_to_run); @@ -389,7 +389,7 @@ fn check_compiling(filename: ~str) -> happiness { stage1/bin/rustc", ~[filename]); - //#error("Status: %d", p.status); + //error!{"Status: %d", p.status}; if p.status == 0 { passed } else if p.err != ~"" { @@ -519,9 +519,9 @@ fn check_roundtrip_convergence(code: @~str, maxIters: uint) { } if oldv == newv { - #error("Converged after %u iterations", i); + error!{"Converged after %u iterations", i}; } else { - #error("Did not converge after %u iterations!", i); + 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", @@ -532,12 +532,12 @@ fn check_roundtrip_convergence(code: @~str, maxIters: uint) { } fn check_convergence(files: ~[~str]) { - #error("pp convergence tests: %u files", vec::len(files)); + error!{"pp convergence tests: %u files", vec::len(files)}; for files.each |file| { if !file_might_not_converge(file) { let s = @result::get(io::read_whole_file_str(file)); if !content_might_not_converge(*s) { - #error("pp converge: %s", file); + error!{"pp converge: %s", file}; // Change from 7u to 2u once // https://github.com/mozilla/rust/issues/850 is fixed check_roundtrip_convergence(s, 7u); @@ -549,8 +549,8 @@ fn check_convergence(files: ~[~str]) { 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\ - file_might_not_converge"); + error!{"Skipping convergence test based on\ + file_might_not_converge"}; again; } @@ -572,7 +572,7 @@ fn check_variants(files: ~[~str], cx: context) { file, s, ~[], sess); io::with_str_reader(*s, |rdr| { - #error("%s", + error!{"%s", as_str(|a| pprust::print_crate( sess.cm, // Assuming no token_trees @@ -583,7 +583,7 @@ fn check_variants(files: ~[~str], cx: context) { file, rdr, a, pprust::no_ann(), - false) )) + false) )} }); check_variants_of_ast(*crate, sess.cm, file, cx); } @@ -591,21 +591,21 @@ fn check_variants(files: ~[~str], cx: context) { fn main(args: ~[~str]) { if vec::len(args) != 2u { - #error("usage: %s <testdir>", args[0]); + error!{"usage: %s <testdir>", args[0]}; ret; } let mut files = ~[]; let root = args[1]; find_rust_files(files, root); - #error("== check_convergence =="); + error!{"== check_convergence =="}; check_convergence(files); - #error("== check_variants: converge =="); + error!{"== check_variants: converge =="}; check_variants(files, { mode: tm_converge }); - #error("== check_variants: run =="); + error!{"== check_variants: run =="}; check_variants(files, { mode: tm_run }); - #error("Fuzzer done"); + error!{"Fuzzer done"}; } // Local Variables: diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs index 21a1fd09c62..7eec13c1b1a 100644 --- a/src/libcore/extfmt.rs +++ b/src/libcore/extfmt.rs @@ -21,7 +21,7 @@ combinations at the moment. Example: -#debug("hello, %s!", "world"); +debug!{"hello, %s!", "world"}; */ @@ -438,7 +438,7 @@ mod test { #[test] fn fmt_slice() { let s = "abc"; - let _s = #fmt("%s", s); + let _s = fmt!{"%s", s}; } } diff --git a/src/libcore/future.rs b/src/libcore/future.rs index 86837285c2b..83dc6b7178b 100644 --- a/src/libcore/future.rs +++ b/src/libcore/future.rs @@ -7,7 +7,7 @@ * ~~~ * let delayed_fib = future::spawn {|| fib(5000) }; * make_a_sandwich(); - * io::println(#fmt("fib(5000) = %?", delayed_fib.get())) + * io::println(fmt!{"fib(5000) = %?", delayed_fib.get()}) * ~~~ */ diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs index 9c85473e761..1445c43df79 100644 --- a/src/libcore/hash.rs +++ b/src/libcore/hash.rs @@ -20,7 +20,7 @@ pure fn hash_bytes_keyed(buf: &[const u8], k0: u64, k1: u64) -> u64 { let mut v2 : u64 = k0 ^ 0x6c79_6765_6e65_7261; let mut v3 : u64 = k1 ^ 0x7465_6462_7974_6573; - #macro([#u8to64_le(buf,i), + #macro[[#u8to64_le(buf,i), (buf[0+i] as u64 | buf[1+i] as u64 << 8 | buf[2+i] as u64 << 16 | @@ -28,16 +28,16 @@ pure fn hash_bytes_keyed(buf: &[const u8], k0: u64, k1: u64) -> u64 { buf[4+i] as u64 << 32 | buf[5+i] as u64 << 40 | buf[6+i] as u64 << 48 | - buf[7+i] as u64 << 56)]); + buf[7+i] as u64 << 56)]]; - #macro([#rotl(x,b), (x << b) | (x >> (64 - b))]); + #macro[[#rotl(x,b), (x << b) | (x >> (64 - b))]]; - #macro([#compress(v0,v1,v2,v3), { + #macro[[#compress(v0,v1,v2,v3), { v0 += v1; v1 = #rotl(v1, 13); v1 ^= v0; v0 = #rotl(v0, 32); v2 += v3; v3 = #rotl(v3, 16); v3 ^= v2; v0 += v3; v3 = #rotl(v3, 21); v3 ^= v0; v2 += v1; v1 = #rotl(v1, 17); v1 ^= v2; v2 = #rotl(v2, 32); - }]); + }]]; let len = vec::len(buf); let end = len & (!0x7); @@ -45,10 +45,10 @@ pure fn hash_bytes_keyed(buf: &[const u8], k0: u64, k1: u64) -> u64 { let mut i = 0; while i < end { - let m = #u8to64_le(buf, i); + let m = u8to64_le!{buf, i}; v3 ^= m; - #compress(v0,v1,v2,v3); - #compress(v0,v1,v2,v3); + compress!{v0,v1,v2,v3}; + compress!{v0,v1,v2,v3}; v0 ^= m; i += 8; } @@ -64,16 +64,16 @@ pure fn hash_bytes_keyed(buf: &[const u8], k0: u64, k1: u64) -> u64 { if left > 6 { b |= buf[i + 6] as u64 << 48; } v3 ^= b; - #compress(v0,v1,v2,v3); - #compress(v0,v1,v2,v3); + compress!{v0,v1,v2,v3}; + compress!{v0,v1,v2,v3}; v0 ^= b; v2 ^= 0xff; - #compress(v0,v1,v2,v3); - #compress(v0,v1,v2,v3); - #compress(v0,v1,v2,v3); - #compress(v0,v1,v2,v3); + compress!{v0,v1,v2,v3}; + compress!{v0,v1,v2,v3}; + compress!{v0,v1,v2,v3}; + compress!{v0,v1,v2,v3}; ret v0 ^ v1 ^ v2 ^ v3; } @@ -127,11 +127,11 @@ fn siphash(key0 : u64, key1 : u64) -> streaming { t += 1; } - let m = #u8to64_le(st.tail, 0); + let m = u8to64_le!{st.tail, 0}; st.v3 ^= m; - #compress(st.v0, st.v1, st.v2, st.v3); - #compress(st.v0, st.v1, st.v2, st.v3); + compress!{st.v0, st.v1, st.v2, st.v3}; + compress!{st.v0, st.v1, st.v2, st.v3}; st.v0 ^= m; st.ntail = 0; @@ -143,11 +143,11 @@ fn siphash(key0 : u64, key1 : u64) -> streaming { let mut i = needed; while i < end { - let mi = #u8to64_le(msg, i); + let mi = u8to64_le!{msg, i}; st.v3 ^= mi; - #compress(st.v0, st.v1, st.v2, st.v3); - #compress(st.v0, st.v1, st.v2, st.v3); + compress!{st.v0, st.v1, st.v2, st.v3}; + compress!{st.v0, st.v1, st.v2, st.v3}; st.v0 ^= mi; i += 8; @@ -179,15 +179,15 @@ fn siphash(key0 : u64, key1 : u64) -> streaming { if st.ntail > 6 { b |= st.tail[6] as u64 << 48; } v3 ^= b; - #compress(v0, v1, v2, v3); - #compress(v0, v1, v2, v3); + compress!{v0, v1, v2, v3}; + compress!{v0, v1, v2, v3}; v0 ^= b; v2 ^= 0xff; - #compress(v0, v1, v2, v3); - #compress(v0, v1, v2, v3); - #compress(v0, v1, v2, v3); - #compress(v0, v1, v2, v3); + compress!{v0, v1, v2, v3}; + compress!{v0, v1, v2, v3}; + compress!{v0, v1, v2, v3}; + compress!{v0, v1, v2, v3}; let h = v0 ^ v1 ^ v2 ^ v3; @@ -323,10 +323,10 @@ fn test_siphash() { } while t < 64 { - #debug("siphash test %?", t); - let vec = #u8to64_le(vecs[t], 0); + debug!{"siphash test %?", t}; + let vec = u8to64_le!{vecs[t], 0}; let out = hash_bytes_keyed(buf, k0, k1); - #debug("got %?, expected %?", out, vec); + debug!{"got %?, expected %?", out, vec}; assert vec == out; stream_full.reset(); @@ -334,7 +334,7 @@ fn test_siphash() { let f = stream_full.result_str(); let i = stream_inc.result_str(); let v = to_hex_str(vecs[t]); - #debug["%d: (%s) => inc=%s full=%s", t, v, i, f]; + debug!{"%d: (%s) => inc=%s full=%s", t, v, i, f}; assert f == i && f == v; diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs index 2b950e4a797..acde4ad4265 100644 --- a/src/libcore/int-template.rs +++ b/src/libcore/int-template.rs @@ -144,8 +144,8 @@ impl times of iter::times for T { `for int::range(0, x) |_i| { /* anything */ }`."] fn times(it: fn() -> bool) { if self < 0 { - fail #fmt("The .times method expects a nonnegative number, \ - but found %?", self); + fail fmt!{"The .times method expects a nonnegative number, \ + but found %?", self}; } let mut i = self; while i > 0 { @@ -161,8 +161,8 @@ impl timesi of iter::timesi for T { fn timesi(it: fn(uint) -> bool) { let slf = self as uint; if slf < 0u { - fail #fmt("The .timesi method expects a nonnegative number, \ - but found %?", self); + fail fmt!{"The .timesi method expects a nonnegative number, \ + but found %?", self}; } let mut i = 0u; while i < slf { diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 492ea83c4a1..e83842232e6 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -291,7 +291,7 @@ impl of reader for byte_buf { ret b as int; } // FIXME (#2738): implement this - fn unread_byte(_byte: int) { #error("Unimplemented: unread_byte"); fail; } + fn unread_byte(_byte: int) { error!{"Unimplemented: unread_byte"}; fail; } fn eof() -> bool { self.pos == self.len } fn seek(offset: int, whence: seek_style) { let pos = self.pos; @@ -357,7 +357,7 @@ impl of writer for *libc::FILE { let nout = libc::fwrite(vbuf as *c_void, len as size_t, 1u as size_t, self); if nout < 1 as size_t { - #error("error writing buffer"); + error!{"error writing buffer"}; log(error, os::last_os_error()); fail; } @@ -392,7 +392,7 @@ impl of writer for fd_t { let vb = ptr::const_offset(vbuf, count) as *c_void; let nout = libc::write(self, vb, len as size_t); if nout < 0 as ssize_t { - #error("error writing buffer"); + error!{"error writing buffer"}; log(error, os::last_os_error()); fail; } @@ -401,11 +401,11 @@ impl of writer for fd_t { } } fn seek(_offset: int, _whence: seek_style) { - #error("need 64-bit foreign calls for seek, sorry"); + error!{"need 64-bit foreign calls for seek, sorry"}; fail; } fn tell() -> uint { - #error("need 64-bit foreign calls for tell, sorry"); + error!{"need 64-bit foreign calls for tell, sorry"}; fail; } fn flush() -> int { 0 } @@ -452,7 +452,7 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag]) (S_IRUSR | S_IWUSR) as c_int) }; if fd < (0 as c_int) { - result::err(#fmt("error opening %s: %s", path, os::last_os_error())) + result::err(fmt!{"error opening %s: %s", path, os::last_os_error()}) } else { result::ok(fd_writer(fd, true)) } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index e4e57b7ec78..e54fbabb0aa 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -169,7 +169,7 @@ fn max<A:copy,IA:base_iter<A>>(self: IA) -> A { #[test] fn test_enumerate() { enumerate(["0", "1", "2"]) {|i,j| - assert #fmt["%u",i] == j; + assert fmt!{"%u",i} == j; } } @@ -247,7 +247,7 @@ fn test_flat_map_with_list() { let a = bind vec::iter(~[0, 1, 2, 3], _); let b = bind flat_map(a, repeat, _); let c = to_vec(b); - #debug["c = %?", c]; + debug!{"c = %?", c}; assert c == ~[1, 2, 2, 3, 3, 3]; } @@ -258,7 +258,7 @@ fn test_repeat() { c += ~[(i * i)]; i += 1u; }; - #debug["c = %?", c]; + debug!{"c = %?", c}; assert c == ~[0u, 1u, 4u, 9u, 16u]; } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index bc36775d0ca..4edf5af5f80 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -995,7 +995,7 @@ mod tests { assert (libc::fclose(ostream) == (0u as c_int)); let rs = os::copy_file(in, out); if (!os::path_exists(in)) { - fail (#fmt("%s doesn't exist", in)); + fail (fmt!{"%s doesn't exist", in}); } assert(rs); let rslt = run::run_program(~"diff", ~[in, out]); diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 5aefd77e07d..873ffd05aa5 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -222,7 +222,7 @@ class buffer_resource<T: send> { let buffer: ~buffer<T>; new(+b: ~buffer<T>) { //let p = ptr::addr_of(*b); - //#error("take %?", p); + //error!{"take %?", p}; atomic_add_acq(b.header.ref_count, 1); self.buffer = b; } @@ -230,7 +230,7 @@ class buffer_resource<T: send> { drop unsafe { let b = move!{self.buffer}; //let p = ptr::addr_of(*b); - //#error("drop %?", p); + //error!{"drop %?", p}; let old_count = atomic_sub_rel(b.header.ref_count, 1); //let old_count = atomic_xchng_rel(b.header.ref_count, 0); if old_count == 1 { @@ -262,7 +262,7 @@ fn send<T: send, Tbuffer: send>(-p: send_packet_buffered<T, Tbuffer>, } full { fail ~"duplicate send" } blocked { - #debug("waking up task for %?", p_); + debug!{"waking up task for %?", p_}; alt p.header.blocked_task { some(task) { rustrt::task_signal_event( @@ -301,7 +301,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>) blocked); alt old_state { empty { - #debug("no data available on %?, going to sleep.", p_); + debug!{"no data available on %?, going to sleep.", p_}; if count == 0 { wait_event(this); } @@ -314,7 +314,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>) // sometimes blocking the thing we are waiting on. task::yield(); } - #debug("woke up, p.state = %?", copy p.header.state); + debug!{"woke up, p.state = %?", copy p.header.state}; } blocked { if first { @@ -418,7 +418,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint { } while !data_avail { - #debug("sleeping on %? packets", pkts.len()); + debug!{"sleeping on %? packets", pkts.len()}; let event = wait_event(this) as *packet_header; let pos = vec::position(pkts, |p| p == event); @@ -428,16 +428,16 @@ fn wait_many(pkts: &[*packet_header]) -> uint { data_avail = true; } none { - #debug("ignoring spurious event, %?", event); + debug!{"ignoring spurious event, %?", event}; } } } - #debug("%?", pkts[ready_packet]); + debug!{"%?", pkts[ready_packet]}; for pkts.each |p| { unsafe{ (*p).unblock()} } - #debug("%?, %?", ready_packet, pkts[ready_packet]); + debug!{"%?, %?", ready_packet, pkts[ready_packet]}; unsafe { assert (*pkts[ready_packet]).state == full @@ -510,7 +510,7 @@ class send_packet_buffered<T: send, Tbuffer: send> { let mut p: option<*packet<T>>; let mut buffer: option<buffer_resource<Tbuffer>>; new(p: *packet<T>) { - //#debug("take send %?", p); + //debug!{"take send %?", p}; self.p = some(p); unsafe { self.buffer = some( @@ -520,17 +520,17 @@ class send_packet_buffered<T: send, Tbuffer: send> { } drop { //if self.p != none { - // #debug("drop send %?", option::get(self.p)); + // debug!{"drop send %?", option::get(self.p)}; //} if self.p != none { let mut p = none; p <-> self.p; sender_terminate(option::unwrap(p)) } - //unsafe { #error("send_drop: %?", + //unsafe { error!{"send_drop: %?", // if self.buffer == none { // "none" - // } else { "some" }); } + // } else { "some" }}; } } fn unwrap() -> *packet<T> { let mut p = none; @@ -553,7 +553,7 @@ class send_packet_buffered<T: send, Tbuffer: send> { } fn reuse_buffer() -> buffer_resource<Tbuffer> { - //#error("send reuse_buffer"); + //error!{"send reuse_buffer"}; let mut tmp = none; tmp <-> self.buffer; option::unwrap(tmp) @@ -570,7 +570,7 @@ class recv_packet_buffered<T: send, Tbuffer: send> : selectable { let mut p: option<*packet<T>>; let mut buffer: option<buffer_resource<Tbuffer>>; new(p: *packet<T>) { - //#debug("take recv %?", p); + //debug!{"take recv %?", p}; self.p = some(p); unsafe { self.buffer = some( @@ -580,17 +580,17 @@ class recv_packet_buffered<T: send, Tbuffer: send> : selectable { } drop { //if self.p != none { - // #debug("drop recv %?", option::get(self.p)); + // debug!{"drop recv %?", option::get(self.p)}; //} if self.p != none { let mut p = none; p <-> self.p; receiver_terminate(option::unwrap(p)) } - //unsafe { #error("recv_drop: %?", + //unsafe { error!{"recv_drop: %?", // if self.buffer == none { // "none" - // } else { "some" }); } + // } else { "some" }}; } } fn unwrap() -> *packet<T> { let mut p = none; @@ -613,7 +613,7 @@ class recv_packet_buffered<T: send, Tbuffer: send> : selectable { } fn reuse_buffer() -> buffer_resource<Tbuffer> { - //#error("recv reuse_buffer"); + //error!{"recv reuse_buffer"}; let mut tmp = none; tmp <-> self.buffer; option::unwrap(tmp) diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs index b126ac64bdd..00bbe3d032a 100644 --- a/src/libcore/priv.rs +++ b/src/libcore/priv.rs @@ -65,7 +65,7 @@ unsafe fn chan_from_global_ptr<T: send>( log(debug,~"BEFORE COMPARE AND SWAP"); let swapped = compare_and_swap( global, 0u, unsafe::reinterpret_cast(ch)); - log(debug,#fmt("AFTER .. swapped? %?", swapped)); + log(debug,fmt!{"AFTER .. swapped? %?", swapped}); if swapped { // Success! diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 16979f7ad95..85e5b43a998 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -327,7 +327,7 @@ mod tests { let ra = rand::seeded_rng(seed); // Regression test that isaac is actually using the above vector let r = ra.next(); - #error("%?", r); + error!{"%?", r}; assert r == 890007737u32 // on x86_64 || r == 2935188040u32; // on x86 } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 0abf3ce299b..2e9fd977536 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -21,7 +21,7 @@ pure fn get<T: copy, U>(res: result<T, U>) -> T { alt res { ok(t) { t } err(the_err) { - unchecked{ fail #fmt("get called on error result: %?", the_err); } + unchecked{ fail fmt!{"get called on error result: %?", the_err}; } } } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index 40b1d1a2d26..f2e3981fd87 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -103,7 +103,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>, for vec::each(es) |e| { let (k,v) = e; - let t = @(#fmt("%s=%s", k, v)); + let t = @(fmt!{"%s=%s", k, v}); vec::push(tmps, t); vec::push_all(ptrs, str::as_c_str(*t, |b| ~[b])); } @@ -130,7 +130,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>, let mut blk : ~[u8] = ~[]; for vec::each(es) |e| { let (k,v) = e; - let t = #fmt("%s=%s", k, v); + let t = fmt!{"%s=%s", k, v}; let mut v : ~[u8] = ::unsafe::reinterpret_cast(t); blk += v; ::unsafe::forget(v); @@ -329,7 +329,7 @@ fn program_output(prog: ~str, args: ~[~str]) -> fn writeclose(fd: c_int, s: ~str) { import io::writer_util; - #error("writeclose %d, %s", fd as int, s); + error!{"writeclose %d, %s", fd as int, s}; let writer = io::fd_writer(fd, false); writer.write_str(s); diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs index 2c485077ea9..24af1d0aedf 100644 --- a/src/libcore/send_map.rs +++ b/src/libcore/send_map.rs @@ -78,7 +78,7 @@ mod linear { pure fn next_bucket(idx: uint, len_buckets: uint) -> uint { let n = (idx + 1) % len_buckets; unsafe{ // argh. log not considered pure. - #debug["next_bucket(%?, %?) = %?", idx, len_buckets, n]; + debug!{"next_bucket(%?, %?) = %?", idx, len_buckets, n}; } ret n; } @@ -163,15 +163,15 @@ mod linear { unsafe{borrow(k)}) { table_full => {fail ~"Internal logic error";} found_hole(idx) { - #debug["insert fresh (%?->%?) at idx %?, hash %?", - k, v, idx, hash]; + debug!{"insert fresh (%?->%?) at idx %?, hash %?", + k, v, idx, hash}; self.buckets[idx] = some({hash: hash, key: k, value: v}); self.size += 1; ret true; } found_entry(idx) => { - #debug["insert overwrite (%?->%?) at idx %?, hash %?", - k, v, idx, hash]; + debug!{"insert overwrite (%?->%?) at idx %?, hash %?", + k, v, idx, hash}; self.buckets[idx] = some({hash: hash, key: k, value: v}); ret false; } @@ -269,7 +269,7 @@ mod linear { fn get(k: &K) -> V { let value = self.find(k); if value.is_none() { - fail #fmt["No entry found for key: %?", k]; + fail fmt!{"No entry found for key: %?", k}; } option::unwrap(value) } diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs index 8964067da0b..3539f411006 100644 --- a/src/libcore/stackwalk.rs +++ b/src/libcore/stackwalk.rs @@ -16,7 +16,7 @@ class frame { fn walk_stack(visit: fn(frame) -> bool) { - #debug("beginning stack walk"); + debug!{"beginning stack walk"}; do frame_address |frame_pointer| { let mut frame_address: *word = unsafe { @@ -25,14 +25,14 @@ fn walk_stack(visit: fn(frame) -> bool) { loop { let fr = frame(frame_address); - #debug("frame: %x", unsafe { reinterpret_cast(fr.fp) }); + debug!{"frame: %x", unsafe { reinterpret_cast(fr.fp) }}; visit(fr); unsafe { let next_fp: **word = reinterpret_cast(frame_address); frame_address = *next_fp; if *frame_address == 0u { - #debug("encountered task_start_wrapper. ending walk"); + debug!{"encountered task_start_wrapper. ending walk"}; // This is the task_start_wrapper_frame. There is // no stack beneath it and it is a foreign frame. break; diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 85de50c5a0f..6c443dc294a 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -1461,7 +1461,7 @@ pure fn is_char_boundary(s: &str, index: uint) -> bool { * let i = 0u; * while i < str::len(s) { * let {ch, next} = str::char_range_at(s, i); - * std::io::println(#fmt("%u: %c",i,ch)); + * std::io::println(fmt!{"%u: %c",i,ch}); * i = next; * } * ~~~ @@ -2141,7 +2141,7 @@ mod tests { fn t(s: ~str, c: char, u: ~[~str]) { log(debug, ~"split_byte: " + s); let v = split_char(s, c); - #debug("split_byte to: %?", v); + debug!{"split_byte to: %?", v}; assert vec::all2(v, u, |a,b| a == b); } t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]); @@ -2170,8 +2170,8 @@ mod tests { 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); + 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"]); diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 610dd43835c..f71f991c9f8 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -278,37 +278,37 @@ mod tests { fn reccyeq(a: reccy, b: reccy) -> bool { ret a.x == b.x && a.y == b.y && taggyeq(a.t, b.t); } - #debug("*** test boxes"); + debug!{"*** test boxes"}; test_boxes(@5, @72, @64, @175); - #debug("*** end test boxes"); - #debug("test parameterized: int"); + debug!{"*** end test boxes"}; + debug!{"test parameterized: int"}; let eq1: eqfn<int> = inteq; test_parameterized::<int>(eq1, 5, 72, 64, 175); - #debug("*** test parameterized: @int"); + debug!{"*** test parameterized: @int"}; let eq2: eqfn<@int> = intboxeq; test_parameterized::<@int>(eq2, @5, @72, @64, @175); - #debug("*** end test parameterized @int"); - #debug("test parameterized: taggy"); + debug!{"*** end test parameterized @int"}; + debug!{"test parameterized: taggy"}; let eq3: eqfn<taggy> = taggyeq; test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3), two(17, 42)); - #debug("*** test parameterized: taggypar<int>"); + debug!{"*** test parameterized: taggypar<int>"}; let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y); test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1), twopar::<int>(1, 2), threepar::<int>(1, 2, 3), twopar::<int>(17, 42)); - #debug("*** end test parameterized: taggypar::<int>"); + debug!{"*** end test parameterized: taggypar::<int>"}; - #debug("*** test parameterized: reccy"); + debug!{"*** test parameterized: reccy"}; let reccy1: reccy = {x: 1, y: 2, t: one(1)}; let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)}; let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)}; let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)}; let eq5: eqfn<reccy> = reccyeq; test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4); - #debug("*** end test parameterized: reccy"); - #debug("*** done"); + debug!{"*** end test parameterized: reccy"}; + debug!{"*** done"}; } } diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 8dbb39d1831..d5d1e70bc7b 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -80,7 +80,7 @@ fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} { (data[start + 2u] as uint) << 8u | (data[start + 3u] as uint), next: start + 4u}; - } else { #error("vint too big"); fail; } + } else { error!{"vint too big"}; fail; } } fn doc(data: @~[u8]) -> doc { @@ -112,7 +112,7 @@ fn get_doc(d: doc, tg: uint) -> doc { alt maybe_get_doc(d, tg) { some(d) { ret d; } none { - #error("failed to find block with tag %u", tg); + error!{"failed to find block with tag %u", tg}; fail; } } @@ -200,7 +200,7 @@ fn write_sized_vuint(w: io::writer, n: uint, size: uint) { w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8, (n >> 8_u) as u8, n as u8]); } - _ { fail #fmt("vint to write too big: %?", n); } + _ { fail fmt!{"vint to write too big: %?", n}; } }; } @@ -209,7 +209,7 @@ fn write_vuint(w: io::writer, n: uint) { if n < 0x4000_u { write_sized_vuint(w, n, 2u); ret; } if n < 0x200000_u { write_sized_vuint(w, n, 3u); ret; } if n < 0x10000000_u { write_sized_vuint(w, n, 4u); ret; } - fail #fmt("vint to write too big: %?", n); + fail fmt!{"vint to write too big: %?", n}; } fn writer(w: io::writer) -> writer { @@ -220,7 +220,7 @@ fn writer(w: io::writer) -> writer { // FIXME (#2741): Provide a function to write the standard ebml header. impl writer for writer { fn start_tag(tag_id: uint) { - #debug["Start tag %u", tag_id]; + debug!{"Start tag %u", tag_id}; // Write the enum ID: write_vuint(self.writer, tag_id); @@ -239,7 +239,7 @@ impl writer for writer { write_sized_vuint(self.writer, size, 4u); self.writer.seek(cur_pos as int, io::seek_set); - #debug["End tag (size = %u)", size]; + debug!{"End tag (size = %u)", size}; } fn wr_tag(tag_id: uint, blk: fn()) { @@ -309,12 +309,12 @@ impl writer for writer { } fn wr_bytes(b: &[u8]) { - #debug["Write %u bytes", vec::len(b)]; + debug!{"Write %u bytes", vec::len(b)}; self.writer.write(b); } fn wr_str(s: ~str) { - #debug["Write str: %?", s]; + debug!{"Write str: %?", s}; self.writer.write(str::bytes(s)); } } @@ -437,29 +437,29 @@ impl deserializer_priv for ebml_deserializer { self.pos = r_doc.end; let str = ebml::doc_as_str(r_doc); if lbl != str { - fail #fmt["Expected label %s but found %s", lbl, str]; + fail fmt!{"Expected label %s but found %s", lbl, str}; } } } } fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc { - #debug[". next_doc(exp_tag=%?)", exp_tag]; + debug!{". next_doc(exp_tag=%?)", exp_tag}; if self.pos >= self.parent.end { fail ~"no more documents in current node!"; } let {tag: r_tag, doc: r_doc} = ebml::doc_at(self.parent.data, self.pos); - #debug["self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?", + debug!{"self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?", copy self.parent.start, copy self.parent.end, - copy self.pos, r_tag, r_doc.start, r_doc.end]; + copy self.pos, r_tag, r_doc.start, r_doc.end}; if r_tag != (exp_tag as uint) { - fail #fmt["expected EMBL doc with tag %? but found tag %?", - exp_tag, r_tag]; + fail fmt!{"expected EMBL doc with tag %? but found tag %?", + exp_tag, r_tag}; } if r_doc.end > self.parent.end { - fail #fmt["invalid EBML, child extends to 0x%x, parent to 0x%x", - r_doc.end, self.parent.end]; + fail fmt!{"invalid EBML, child extends to 0x%x, parent to 0x%x", + r_doc.end, self.parent.end}; } self.pos = r_doc.end; ret r_doc; @@ -478,7 +478,7 @@ impl deserializer_priv for ebml_deserializer { fn _next_uint(exp_tag: ebml_serializer_tag) -> uint { let r = ebml::doc_as_u32(self.next_doc(exp_tag)); - #debug["_next_uint exp_tag=%? result=%?", exp_tag, r]; + debug!{"_next_uint exp_tag=%? result=%?", exp_tag, r}; ret r as uint; } } @@ -493,7 +493,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer { fn read_uint() -> uint { let v = ebml::doc_as_u64(self.next_doc(es_uint)); if v > (core::uint::max_value as u64) { - fail #fmt["uint %? too large for this architecture", v]; + fail fmt!{"uint %? too large for this architecture", v}; } ret v as uint; } @@ -505,7 +505,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer { fn read_int() -> int { let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64; if v > (int::max_value as i64) || v < (int::min_value as i64) { - fail #fmt["int %? out of range for this architecture", v]; + fail fmt!{"int %? out of range for this architecture", v}; } ret v as int; } @@ -520,67 +520,67 @@ impl deserializer of serialization::deserializer for ebml_deserializer { // Compound types: fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T { - #debug["read_enum(%s)", name]; + debug!{"read_enum(%s)", name}; self._check_label(name); self.push_doc(self.next_doc(es_enum), f) } fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T { - #debug["read_enum_variant()"]; + debug!{"read_enum_variant()"}; let idx = self._next_uint(es_enum_vid); - #debug[" idx=%u", idx]; + debug!{" idx=%u", idx}; do self.push_doc(self.next_doc(es_enum_body)) { f(idx) } } fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T { - #debug["read_enum_variant_arg(idx=%u)", idx]; + debug!{"read_enum_variant_arg(idx=%u)", idx}; f() } fn read_vec<T:copy>(f: fn(uint) -> T) -> T { - #debug["read_vec()"]; + debug!{"read_vec()"}; do self.push_doc(self.next_doc(es_vec)) { let len = self._next_uint(es_vec_len); - #debug[" len=%u", len]; + debug!{" len=%u", len}; f(len) } } fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T { - #debug["read_vec_elt(idx=%u)", idx]; + debug!{"read_vec_elt(idx=%u)", idx}; self.push_doc(self.next_doc(es_vec_elt), f) } fn read_box<T:copy>(f: fn() -> T) -> T { - #debug["read_box()"]; + debug!{"read_box()"}; f() } fn read_uniq<T:copy>(f: fn() -> T) -> T { - #debug["read_uniq()"]; + debug!{"read_uniq()"}; f() } fn read_rec<T:copy>(f: fn() -> T) -> T { - #debug["read_rec()"]; + debug!{"read_rec()"}; f() } 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]; + debug!{"read_rec_field(%s, idx=%u)", f_name, f_idx}; self._check_label(f_name); f() } fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T { - #debug["read_tup(sz=%u)", sz]; + debug!{"read_tup(sz=%u)", sz}; f() } fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T { - #debug["read_tup_elt(idx=%u)", idx]; + debug!{"read_tup_elt(idx=%u)", idx}; f() } } @@ -631,14 +631,14 @@ fn test_option_int() { } fn test_v(v: option<int>) { - #debug["v == %?", v]; + debug!{"v == %?", v}; let mbuf = io::mem_buffer(); let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf)); serialize_0(ebml_w, v); let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf)); let deser = ebml_deserializer(ebml_doc); let v1 = deserialize_0(deser); - #debug["v1 == %?", v1]; + debug!{"v1 == %?", v1}; assert v == v1; } diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 8ba2dc16b76..3cafc118525 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -314,7 +314,7 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe { 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 } + none { error!{"No option '%s' defined", nm}; fail } }; } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 74707e36a51..ee265269872 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -632,7 +632,7 @@ impl of to_str::to_str for json { impl of to_str::to_str for error { fn to_str() -> ~str { - #fmt("%u:%u: %s", self.line, self.col, *self.msg) + fmt!{"%u:%u: %s", self.line, self.col, *self.msg} } } diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 2522c9d5876..c660adc527f 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -122,16 +122,16 @@ mod chained { loop { alt copy e0.next { absent { - #debug("search_tbl: absent, comp %u, hash %u, idx %u", - comp, h, idx); + debug!{"search_tbl: absent, comp %u, hash %u, idx %u", + comp, h, idx}; ret not_found; } present(e1) { comp += 1u; if e1.hash == h && self.eqer(e1.key, k) { - #debug("search_tbl: present, comp %u, \ + debug!{"search_tbl: present, comp %u, \ hash %u, idx %u", - comp, h, idx); + comp, h, idx}; ret found_after(e0, e1); } else { e0 = e1; @@ -145,14 +145,14 @@ mod chained { let idx = h % vec::len(self.chains); alt copy self.chains[idx] { absent { - #debug("search_tbl: absent, comp %u, hash %u, idx %u", - 0u, h, idx); + debug!{"search_tbl: absent, comp %u, hash %u, idx %u", + 0u, h, idx}; ret not_found; } present(e) { if e.hash == h && self.eqer(e.key, k) { - #debug("search_tbl: present, comp %u, hash %u, idx %u", - 1u, h, idx); + debug!{"search_tbl: present, comp %u, hash %u, idx %u", + 1u, h, idx}; ret found_first(idx, e); } else { ret self.search_rem(k, h, idx, e); @@ -248,7 +248,7 @@ mod chained { fn get(k: K) -> V { alt self.find(k) { some(v) => {v} - none => {fail #fmt["Key not found in table: %?", k]} + none => {fail fmt!{"Key not found in table: %?", k}} } } @@ -427,14 +427,14 @@ mod tests { #[test] fn test_simple() { - #debug("*** starting test_simple"); + debug!{"*** starting test_simple"}; fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; } 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; - #debug("uint -> uint"); + debug!{"uint -> uint"}; let hm_uu: map::hashmap<uint, uint> = map::hashmap::<uint, uint>(hasher_uint, eqer_uint); assert (hm_uu.insert(10u, 12u)); @@ -450,7 +450,7 @@ mod tests { let ten: ~str = ~"ten"; let eleven: ~str = ~"eleven"; let twelve: ~str = ~"twelve"; - #debug("str -> uint"); + debug!{"str -> uint"}; let hm_su: map::hashmap<~str, uint> = map::hashmap::<~str, uint>(hasher_str, eqer_str); assert (hm_su.insert(~"ten", 12u)); @@ -464,7 +464,7 @@ mod tests { assert (hm_su.get(~"twelve") == 14u); assert (!hm_su.insert(~"twelve", 12u)); assert (hm_su.get(~"twelve") == 12u); - #debug("uint -> str"); + debug!{"uint -> str"}; let hm_us: map::hashmap<uint, ~str> = map::hashmap::<uint, ~str>(hasher_uint, eqer_uint); assert (hm_us.insert(10u, ~"twelve")); @@ -477,7 +477,7 @@ mod tests { 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"); + debug!{"str -> str"}; let hm_ss: map::hashmap<~str, ~str> = map::hashmap::<~str, ~str>(hasher_str, eqer_str); assert (hm_ss.insert(ten, ~"twelve")); @@ -490,7 +490,7 @@ mod tests { 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"); + debug!{"*** finished test_simple"}; } @@ -499,11 +499,11 @@ mod tests { */ #[test] fn test_growth() { - #debug("*** starting test_growth"); + debug!{"*** starting test_growth"}; let num_to_insert: uint = 64u; fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; } fn uint_id(&&x: uint) -> uint { x } - #debug("uint -> uint"); + debug!{"uint -> uint"}; let hasher_uint: map::hashfn<uint> = uint_id; let eqer_uint: map::eqfn<uint> = eq_uint; let hm_uu: map::hashmap<uint, uint> = @@ -511,26 +511,26 @@ mod tests { let mut i: uint = 0u; while i < num_to_insert { assert (hm_uu.insert(i, i * i)); - #debug("inserting %u -> %u", i, i*i); + debug!{"inserting %u -> %u", i, i*i}; i += 1u; } - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm_uu.get(i)); + debug!{"get(%u) = %u", i, hm_uu.get(i)}; assert (hm_uu.get(i) == i * i); i += 1u; } assert (hm_uu.insert(num_to_insert, 17u)); assert (hm_uu.get(num_to_insert) == 17u); - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm_uu.get(i)); + debug!{"get(%u) = %u", i, hm_uu.get(i)}; assert (hm_uu.get(i) == i * i); i += 1u; } - #debug("str -> str"); + 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> = @@ -538,17 +538,17 @@ mod tests { i = 0u; while i < num_to_insert { assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)); - #debug("inserting \"%s\" -> \"%s\"", + debug!{"inserting \"%s\" -> \"%s\"", uint::to_str(i, 2u), - uint::to_str(i*i, 2u)); + uint::to_str(i*i, 2u)}; i += 1u; } - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { - #debug("get(\"%s\") = \"%s\"", + debug!{"get(\"%s\") = \"%s\"", uint::to_str(i, 2u), - hm_ss.get(uint::to_str(i, 2u))); + hm_ss.get(uint::to_str(i, 2u))}; assert (str::eq(hm_ss.get(uint::to_str(i, 2u)), uint::to_str(i * i, 2u))); i += 1u; @@ -557,22 +557,22 @@ mod tests { uint::to_str(17u, 2u))); assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)), uint::to_str(17u, 2u))); - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { - #debug("get(\"%s\") = \"%s\"", + debug!{"get(\"%s\") = \"%s\"", uint::to_str(i, 2u), - hm_ss.get(uint::to_str(i, 2u))); + hm_ss.get(uint::to_str(i, 2u))}; assert (str::eq(hm_ss.get(uint::to_str(i, 2u)), uint::to_str(i * i, 2u))); i += 1u; } - #debug("*** finished test_growth"); + debug!{"*** finished test_growth"}; } #[test] fn test_removal() { - #debug("*** starting test_removal"); + debug!{"*** starting test_removal"}; let num_to_insert: uint = 64u; fn eq(&&x: uint, &&y: uint) -> bool { ret x == y; } fn hash(&&u: uint) -> uint { @@ -591,12 +591,12 @@ mod tests { let mut i: uint = 0u; while i < num_to_insert { assert (hm.insert(i, i * i)); - #debug("inserting %u -> %u", i, i*i); + debug!{"inserting %u -> %u", i, i*i}; i += 1u; } assert (hm.size() == num_to_insert); - #debug("-----"); - #debug("removing evens"); + debug!{"-----"}; + debug!{"removing evens"}; i = 0u; while i < num_to_insert { let v = hm.remove(i); @@ -607,44 +607,44 @@ mod tests { i += 2u; } assert (hm.size() == num_to_insert / 2u); - #debug("-----"); + debug!{"-----"}; i = 1u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm.get(i)); + debug!{"get(%u) = %u", i, hm.get(i)}; assert (hm.get(i) == i * i); i += 2u; } - #debug("-----"); + debug!{"-----"}; i = 1u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm.get(i)); + debug!{"get(%u) = %u", i, hm.get(i)}; assert (hm.get(i) == i * i); i += 2u; } - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { assert (hm.insert(i, i * i)); - #debug("inserting %u -> %u", i, i*i); + debug!{"inserting %u -> %u", i, i*i}; i += 2u; } assert (hm.size() == num_to_insert); - #debug("-----"); + debug!{"-----"}; i = 0u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm.get(i)); + debug!{"get(%u) = %u", i, hm.get(i)}; assert (hm.get(i) == i * i); i += 1u; } - #debug("-----"); + debug!{"-----"}; assert (hm.size() == num_to_insert); i = 0u; while i < num_to_insert { - #debug("get(%u) = %u", i, hm.get(i)); + debug!{"get(%u) = %u", i, hm.get(i)}; assert (hm.get(i) == i * i); i += 1u; } - #debug("*** finished test_removal"); + debug!{"*** finished test_removal"}; } #[test] diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 6fb4b3c1b33..38b6d6194eb 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -92,7 +92,7 @@ fn get_addr(++node: ~str, iotask: iotask) -> result::result<~[ip_addr], ip_get_addr_err> unsafe { do comm::listen |output_ch| { do str::as_buf(node) |node_ptr, len| { - log(debug, #fmt("slice len %?", len)); + log(debug, fmt!{"slice len %?", len}); let handle = create_uv_getaddrinfo_t(); let handle_ptr = ptr::addr_of(handle); let handle_data: get_addr_data = { @@ -167,10 +167,10 @@ mod v4 { } }); if vec::len(parts) != 4u { - result::err(#fmt("'%s' doesn't have 4 parts", ip)) + result::err(fmt!{"'%s' doesn't have 4 parts", ip}) } else if vec::contains(parts, 256u) { - result::err(#fmt("invalid octal in addr '%s'", ip)) + result::err(fmt!{"invalid octal in addr '%s'", ip}) } else { result::ok({a: parts[0] as u8, b: parts[1] as u8, @@ -191,8 +191,8 @@ mod v4 { let new_addr = uv_ip4_addr(ip, 22); let reformatted_name = uv_ip4_name(&new_addr); - log(debug, #fmt("try_parse_addr: input ip: %s reparsed ip: %s", - ip, reformatted_name)); + log(debug, fmt!{"try_parse_addr: input ip: %s reparsed ip: %s", + ip, reformatted_name}); let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name); if result::is_err(ref_ip_rep_result) { let err_str = result::get_err(ref_ip_rep_result); @@ -238,13 +238,13 @@ mod v6 { // need to figure out how to establish a parse failure.. let new_addr = uv_ip6_addr(ip, 22); let reparsed_name = uv_ip6_name(&new_addr); - log(debug, #fmt("v6::try_parse_addr ip: '%s' reparsed '%s'", - ip, reparsed_name)); + log(debug, fmt!{"v6::try_parse_addr ip: '%s' reparsed '%s'", + ip, reparsed_name}); // '::' appears to be uv_ip6_name() returns for bogus // parses.. if ip != ~"::" && reparsed_name == ~"::" { - result::err({err_msg:#fmt("failed to parse '%s'", - ip)}) + result::err({err_msg:fmt!{"failed to parse '%s'", + ip}}) } else { result::ok(ipv6(new_addr)) @@ -265,7 +265,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, if status == 0i32 { if res != (ptr::null::<addrinfo>()) { let mut out_vec = ~[]; - log(debug, #fmt("initial addrinfo: %?", res)); + log(debug, fmt!{"initial addrinfo: %?", res}); let mut curr_addr = res; loop { let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) { @@ -292,11 +292,11 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, } else { curr_addr = next_addr; - log(debug, #fmt("next_addr addrinfo: %?", curr_addr)); + log(debug, fmt!{"next_addr addrinfo: %?", curr_addr}); } } - log(debug, #fmt("successful process addrinfo result, len: %?", - vec::len(out_vec))); + log(debug, fmt!{"successful process addrinfo result, len: %?", + vec::len(out_vec)}); (*handle_data).output_ch.send(result::ok(out_vec)); } else { @@ -328,19 +328,19 @@ mod test { fn test_ip_ipv6_parse_and_format_ip() { 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)); + log(debug, fmt!{"results: expected: '%s' actual: '%s'", + localhost_str, format_result}); assert format_result == localhost_str; } #[test] fn test_ip_ipv4_bad_parse() { alt v4::try_parse_addr(~"b4df00d") { result::err(err_info) { - log(debug, #fmt("got error as expected %?", err_info)); + log(debug, fmt!{"got error as expected %?", err_info}); assert true; } result::ok(addr) { - fail #fmt("Expected failure, but got addr %?", addr); + fail fmt!{"Expected failure, but got addr %?", addr}; } } } @@ -349,11 +349,11 @@ mod test { fn test_ip_ipv6_bad_parse() { alt v6::try_parse_addr(~"::,~2234k;") { result::err(err_info) { - log(debug, #fmt("got error as expected %?", err_info)); + log(debug, fmt!{"got error as expected %?", err_info}); assert true; } result::ok(addr) { - fail #fmt("Expected failure, but got addr %?", addr); + fail fmt!{"Expected failure, but got addr %?", addr}; } } } @@ -369,8 +369,8 @@ mod test { // note really sure how to realiably test/assert // this.. mostly just wanting to see it work, atm. let results = result::unwrap(ga_result); - log(debug, #fmt("test_get_addr: Number of results for %s: %?", - localhost_name, vec::len(results))); + log(debug, fmt!{"test_get_addr: Number of results for %s: %?", + localhost_name, vec::len(results)}); for vec::each(results) |r| { let ipv_prefix = alt r { ipv4(_) { @@ -380,8 +380,8 @@ mod test { ~"IPv6" } }; - log(debug, #fmt("test_get_addr: result %s: '%s'", - ipv_prefix, format_addr(r))); + log(debug, fmt!{"test_get_addr: result %s: '%s'", + ipv_prefix, format_addr(r)}); } // at least one result.. this is going to vary from system // to system, based on stuff like the contents of /etc/hosts diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 66f57757560..d70d9b40de8 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -142,15 +142,15 @@ fn connect(-input_ip: ip::ip_addr, port: uint, iotask: iotask }; let socket_data_ptr = ptr::addr_of(*socket_data); - log(debug, #fmt("tcp_connect result_ch %?", conn_data.result_ch)); + log(debug, fmt!{"tcp_connect result_ch %?", conn_data.result_ch}); // get an unsafe representation of our stream_handle_ptr that // we can send into the interact cb to be handled in libuv.. - log(debug, #fmt("stream_handle_ptr outside interact %?", - stream_handle_ptr)); + 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, #fmt("stream_handle_ptr in interact %?", - stream_handle_ptr)); + 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"); @@ -167,7 +167,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, // info.. should probably add an additional // rust type that actually is closer to // what the libuv API expects (ip str + port num) - log(debug, #fmt("addr: %?", addr)); + log(debug, fmt!{"addr: %?", addr}); let in_addr = uv::ll::ip4_addr(addr_str, port as int); uv::ll::tcp_connect( connect_req_ptr, @@ -176,7 +176,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, tcp_connect_on_connect_cb) } ip::ipv6(addr) { - log(debug, #fmt("addr: %?", addr)); + log(debug, fmt!{"addr: %?", addr}); let in_addr = uv::ll::ip6_addr(addr_str, port as int); uv::ll::tcp_connect6( connect_req_ptr, @@ -334,7 +334,7 @@ fn read_start(sock: tcp_socket) fn read_stop(sock: tcp_socket, -read_port: comm::port<result::result<~[u8], tcp_err_data>>) -> result::result<(), tcp_err_data> unsafe { - log(debug, #fmt("taking the read_port out of commission %?", read_port)); + log(debug, fmt!{"taking the read_port out of commission %?", read_port}); let socket_data = ptr::addr_of(*sock.socket_data); read_stop_common_impl(socket_data) } @@ -622,13 +622,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, let addr_str = ip::format_addr(loc_ip); let bind_result = alt loc_ip { ip::ipv4(addr) { - log(debug, #fmt("addr: %?", addr)); + log(debug, fmt!{"addr: %?", addr}); let in_addr = uv::ll::ip4_addr(addr_str, port as int); uv::ll::tcp_bind(server_stream_ptr, ptr::addr_of(in_addr)) } ip::ipv6(addr) { - log(debug, #fmt("addr: %?", addr)); + log(debug, fmt!{"addr: %?", addr}); let in_addr = uv::ll::ip6_addr(addr_str, port as int); uv::ll::tcp_bind6(server_stream_ptr, ptr::addr_of(in_addr)) @@ -668,8 +668,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, alt setup_result { some(err_data) { do iotask::interact(iotask) |loop_ptr| { - log(debug, #fmt("tcp::listen post-kill recv hl interact %?", - loop_ptr)); + log(debug, fmt!{"tcp::listen post-kill recv hl interact %?", + loop_ptr}); (*server_data_ptr).active = false; uv::ll::close(server_stream_ptr, tcp_lfc_close_cb); }; @@ -684,8 +684,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, result::err(address_in_use) } _ { - log(debug, #fmt("Got '%s' '%s' libuv error", - err_data.err_name, err_data.err_msg)); + log(debug, fmt!{"Got '%s' '%s' libuv error", + err_data.err_name, err_data.err_msg}); result::err( generic_listen_err(err_data.err_name, err_data.err_msg)) } @@ -695,8 +695,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, on_establish_cb(kill_ch); let kill_result = comm::recv(kill_po); do iotask::interact(iotask) |loop_ptr| { - log(debug, #fmt("tcp::listen post-kill recv hl interact %?", - loop_ptr)); + log(debug, fmt!{"tcp::listen post-kill recv hl interact %?", + loop_ptr}); (*server_data_ptr).active = false; uv::ll::close(server_stream_ptr, tcp_lfc_close_cb); }; @@ -776,8 +776,8 @@ impl tcp_socket_buf of io::reader for @tcp_socket_buf { if err_data.err_name == ~"EOF" { break; } else { - #debug("ERROR sock_buf as io::reader.read err %? %?", - err_data.err_name, err_data.err_msg); + debug!{"ERROR sock_buf as io::reader.read err %? %?", + err_data.err_name, err_data.err_msg}; ret 0; } @@ -809,7 +809,7 @@ impl tcp_socket_buf of io::reader for @tcp_socket_buf { false // noop } fn seek(dist: int, seek: io::seek_style) { - log(debug, #fmt("tcp_socket_buf seek stub %? %?", dist, seek)); + log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek}); // noop } fn tell() -> uint { @@ -826,12 +826,12 @@ impl tcp_socket_buf of io::writer for @tcp_socket_buf { vec::slice(data, 0, vec::len(data))); if w_result.is_err() { let err_data = w_result.get_err(); - log(debug, #fmt("ERROR sock_buf as io::writer.writer err: %? %?", - err_data.err_name, err_data.err_msg)); + log(debug, fmt!{"ERROR sock_buf as io::writer.writer err: %? %?", + err_data.err_name, err_data.err_msg}); } } fn seek(dist: int, seek: io::seek_style) { - log(debug, #fmt("tcp_socket_buf seek stub %? %?", dist, seek)); + log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek}); // noop } fn tell() -> uint { @@ -856,14 +856,14 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe { let close_data_ptr = ptr::addr_of(close_data); let stream_handle_ptr = (*socket_data).stream_handle_ptr; do iotask::interact((*socket_data).iotask) |loop_ptr| { - log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?", - stream_handle_ptr, loop_ptr)); + log(debug, fmt!{"interact dtor for tcp_socket stream %? loop %?", + stream_handle_ptr, loop_ptr}); uv::ll::set_data_for_uv_handle(stream_handle_ptr, close_data_ptr); uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb); }; comm::recv(closed_po); - log(debug, #fmt("about to free socket_data at %?", socket_data)); + 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"); @@ -946,7 +946,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data) let start_ch = comm::chan(start_po); 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)); + 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) { @@ -990,7 +990,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data, }; let write_data_ptr = ptr::addr_of(write_data); do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| { - log(debug, #fmt("in interact cb for tcp::write %?", loop_ptr)); + log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr}); alt uv::ll::write(write_req_ptr, stream_handle_ptr, write_buf_vec_ptr, @@ -1096,8 +1096,8 @@ impl of to_tcp_err_iface for uv::ll::uv_err_data { extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, nread: libc::ssize_t, ++buf: uv::ll::uv_buf_t) unsafe { - log(debug, #fmt("entering on_tcp_read_cb stream: %? nread: %?", - stream, nread)); + log(debug, fmt!{"entering on_tcp_read_cb stream: %? nread: %?", + stream, nread}); let loop_ptr = uv::ll::get_loop_for_uv_handle(stream); let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream) as *tcp_socket_data; @@ -1105,8 +1105,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, // incoming err.. probably eof -1 { let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err(); - log(debug, #fmt("on_tcp_read_cb: incoming err.. name %? msg %?", - err_data.err_name, err_data.err_msg)); + log(debug, fmt!{"on_tcp_read_cb: incoming err.. name %? msg %?", + err_data.err_name, err_data.err_msg}); let reader_ch = (*socket_data_ptr).reader_ch; comm::send(reader_ch, result::err(err_data)); } @@ -1115,7 +1115,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, // have data _ { // we have data - log(debug, #fmt("tcp on_read_cb nread: %d", nread as int)); + log(debug, fmt!{"tcp on_read_cb nread: %d", nread as int}); let reader_ch = (*socket_data_ptr).reader_ch; let buf_base = uv::ll::get_base_from_buf(buf); let new_bytes = vec::unsafe::from_buf(buf_base, nread as uint); @@ -1131,10 +1131,10 @@ extern fn on_alloc_cb(handle: *libc::c_void, -> uv::ll::uv_buf_t unsafe { 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", + log(debug, fmt!{"tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u", handle, char_ptr as uint, - suggested_size as uint)); + suggested_size as uint}); uv::ll::buf_init(char_ptr, suggested_size as uint) } @@ -1180,11 +1180,11 @@ extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { let data = uv::ll::get_data_for_uv_handle(handle) as *connect_req_data; comm::send((*data).closed_signal_ch, ()); - log(debug, #fmt("exiting steam_error_close_cb for %?", handle)); + log(debug, fmt!{"exiting steam_error_close_cb for %?", handle}); } extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { - log(debug, #fmt("closed client tcp handle %?", handle)); + log(debug, fmt!{"closed client tcp handle %?", handle}); } extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, @@ -1192,7 +1192,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr) as *connect_req_data); let result_ch = (*conn_data_ptr).result_ch; - log(debug, #fmt("tcp_connect result_ch %?", result_ch)); + log(debug, fmt!{"tcp_connect result_ch %?", result_ch}); let tcp_stream_ptr = uv::ll::get_stream_handle_from_connect_req(connect_req_ptr); alt status { @@ -1204,8 +1204,8 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, 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, - err_data.err_msg)); + log(debug, fmt!{"err_data %? %?", err_data.err_name, + err_data.err_msg}); comm::send(result_ch, conn_failure(err_data)); uv::ll::set_data_for_uv_handle(tcp_stream_ptr, conn_data_ptr); @@ -1334,10 +1334,10 @@ mod test { assert actual_resp_result.is_ok(); let actual_resp = actual_resp_result.get(); let actual_req = comm::recv(server_result_po); - log(debug, #fmt("REQ: expected: '%s' actual: '%s'", - expected_req, actual_req)); - log(debug, #fmt("RESP: expected: '%s' actual: '%s'", - expected_resp, actual_resp)); + log(debug, fmt!{"REQ: expected: '%s' actual: '%s'", + expected_req, actual_req}); + log(debug, fmt!{"RESP: expected: '%s' actual: '%s'", + expected_resp, actual_resp}); assert str::contains(actual_req, expected_req); assert str::contains(actual_resp, expected_resp); } @@ -1476,27 +1476,27 @@ mod test { }; let actual_req = comm::recv(server_result_po); - log(debug, #fmt("REQ: expected: '%s' actual: '%s'", - expected_req, actual_req)); - log(debug, #fmt("RESP: expected: '%s' actual: '%s'", - expected_resp, actual_resp)); + log(debug, fmt!{"REQ: expected: '%s' actual: '%s'", + expected_req, actual_req}); + log(debug, fmt!{"RESP: expected: '%s' actual: '%s'", + expected_resp, actual_resp}); assert str::contains(actual_req, expected_req); assert str::contains(actual_resp, expected_resp); } fn buf_write(+w: io::writer, val: ~str) { - log(debug, #fmt("BUF_WRITE: val len %?", str::len(val))); + 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 %?", - vec::len(b_slice))); + log(debug, fmt!{"BUF_WRITE: b_slice len %?", + vec::len(b_slice)}); w.write(b_slice) } } 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))); + log(debug, fmt!{"in buf_read.. new_bytes len: %?", + vec::len(new_bytes)}); str::from_bytes(new_bytes) } @@ -1508,8 +1508,8 @@ mod test { let listen_result = listen(server_ip_addr, server_port, 128u, iotask, // on_establish_cb -- called when listener is set up |kill_ch| { - log(debug, #fmt("establish_cb %?", - kill_ch)); + log(debug, fmt!{"establish_cb %?", + kill_ch}); comm::send(cont_ch, ()); }, // risky to run this on the loop, but some users @@ -1541,8 +1541,8 @@ mod test { alt received_req_bytes { result::ok(data) { log(debug, ~"SERVER: got REQ str::from_bytes.."); - log(debug, #fmt("SERVER: REQ data len: %?", - vec::len(data))); + log(debug, fmt!{"SERVER: REQ data len: %?", + vec::len(data)}); server_ch.send( str::from_bytes(data)); log(debug, ~"SERVER: before write"); @@ -1551,8 +1551,8 @@ mod test { 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)); + 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(~""); } @@ -1569,8 +1569,8 @@ mod test { if result::is_err(listen_result) { alt result::get_err(listen_result) { generic_listen_err(name, msg) { - fail #fmt("SERVER: exited abnormally name %s msg %s", - name, msg); + fail fmt!{"SERVER: exited abnormally name %s msg %s", + name, msg}; } access_denied { fail ~"SERVER: exited abnormally, got access denied.."; @@ -1581,7 +1581,7 @@ mod test { } } let ret_val = server_ch.recv(); - log(debug, #fmt("SERVER: exited and got ret val: '%s'", ret_val)); + log(debug, fmt!{"SERVER: exited and got ret val: '%s'", ret_val}); ret_val } @@ -1591,12 +1591,12 @@ mod test { let listen_result = listen(server_ip_addr, server_port, 128u, iotask, // on_establish_cb -- called when listener is set up |kill_ch| { - log(debug, #fmt("establish_cb %?", - kill_ch)); + log(debug, fmt!{"establish_cb %?", + kill_ch}); }, |new_conn, kill_ch| { - fail #fmt("SERVER: shouldn't be called.. %? %?", - new_conn, kill_ch); + fail fmt!{"SERVER: shouldn't be called.. %? %?", + new_conn, kill_ch}; }); // err check on listen_result if result::is_err(listen_result) { @@ -1632,8 +1632,8 @@ mod test { else { client_ch.send(str::from_bytes(read_result.get())); let ret_val = client_ch.recv(); - log(debug, #fmt("CLIENT: after client_ch recv ret: '%s'", - ret_val)); + log(debug, fmt!{"CLIENT: after client_ch recv ret: '%s'", + ret_val}); ok(ret_val) } } @@ -1645,8 +1645,8 @@ mod test { if result::is_err(write_result) { 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)); + 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"; } diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 3a3aae1ef6d..928f8bc9399 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -72,7 +72,7 @@ fn query_to_str(query: query) -> ~str { let mut strvec = ~[]; for query.each |kv| { let (k, v) = kv; - strvec += ~[#fmt("%s=%s", k, v)]; + strvec += ~[fmt!{"%s=%s", k, v}]; }; ret str::connect(strvec, ~"&"); } diff --git a/src/libstd/par.rs b/src/libstd/par.rs index 3c05a0b5574..65aa077ef87 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -53,11 +53,11 @@ fn map_slices<A: copy send, B: copy send>( let len = end - base; let slice = (ptr::offset(p, base), len * sys::size_of::<A>()); - log(info, #fmt("pre-slice: %?", (base, slice))); + log(info, fmt!{"pre-slice: %?", (base, slice)}); let slice : &[A] = unsafe::reinterpret_cast(slice); - log(info, #fmt("slice: %?", - (base, vec::len(slice), end - base))); + log(info, fmt!{"slice: %?", + (base, vec::len(slice), end - base)}); assert(vec::len(slice) == end - base); f(base, slice) } @@ -68,7 +68,7 @@ fn map_slices<A: copy send, B: copy send>( } log(info, ~"tasks spawned"); - log(info, #fmt("num_tasks: %?", (num_tasks, futures.len()))); + log(info, fmt!{"num_tasks: %?", (num_tasks, futures.len())}); assert(num_tasks == futures.len()); let r = do futures.map() |ys| { diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index dbeb5ab6381..6122474c06d 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -8,63 +8,63 @@ impl of serializer for writer { } fn emit_uint(v: uint) { - self.write_str(#fmt["%?u", v]); + self.write_str(fmt!{"%?u", v}); } fn emit_u64(v: u64) { - self.write_str(#fmt["%?_u64", v]); + self.write_str(fmt!{"%?_u64", v}); } fn emit_u32(v: u32) { - self.write_str(#fmt["%?_u32", v]); + self.write_str(fmt!{"%?_u32", v}); } fn emit_u16(v: u16) { - self.write_str(#fmt["%?_u16", v]); + self.write_str(fmt!{"%?_u16", v}); } fn emit_u8(v: u8) { - self.write_str(#fmt["%?_u8", v]); + self.write_str(fmt!{"%?_u8", v}); } fn emit_int(v: int) { - self.write_str(#fmt["%?", v]); + self.write_str(fmt!{"%?", v}); } fn emit_i64(v: i64) { - self.write_str(#fmt["%?_i64", v]); + self.write_str(fmt!{"%?_i64", v}); } fn emit_i32(v: i32) { - self.write_str(#fmt["%?_i32", v]); + self.write_str(fmt!{"%?_i32", v}); } fn emit_i16(v: i16) { - self.write_str(#fmt["%?_i16", v]); + self.write_str(fmt!{"%?_i16", v}); } fn emit_i8(v: i8) { - self.write_str(#fmt["%?_i8", v]); + self.write_str(fmt!{"%?_i8", v}); } fn emit_bool(v: bool) { - self.write_str(#fmt["%b", v]); + self.write_str(fmt!{"%b", v}); } fn emit_float(v: float) { - self.write_str(#fmt["%?_f", v]); + self.write_str(fmt!{"%?_f", v}); } fn emit_f64(v: f64) { - self.write_str(#fmt["%?_f64", v]); + self.write_str(fmt!{"%?_f64", v}); } fn emit_f32(v: f32) { - self.write_str(#fmt["%?_f32", v]); + self.write_str(fmt!{"%?_f32", v}); } fn emit_str(v: ~str) { - self.write_str(#fmt["%?", v]); + self.write_str(fmt!{"%?", v}); } fn emit_enum(_name: ~str, f: fn()) { diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 0325ef3ac2e..37f829396ab 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -27,7 +27,7 @@ fn mk<T: copy>() -> smallintmap<T> { */ #[inline(always)] fn insert<T: copy>(self: smallintmap<T>, key: uint, val: T) { - //io::println(#fmt("%?", key)); + //io::println(fmt!{"%?", key}); self.v.grow_set_elt(key, none, some(val)); } @@ -49,7 +49,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> { */ pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T { alt find(self, key) { - none { #error("smallintmap::get(): key not present"); fail; } + none { error!{"smallintmap::get(): key not present"}; fail; } some(v) { ret v; } } } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 6558e14c84d..95dbf5f97dc 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -253,7 +253,7 @@ mod test_qsort { let pairs = vec::zip(expected, immut_names); for vec::each(pairs) |p| { let (a, b) = p; - #debug("%d %d", a, b); + debug!{"%d %d", a, b}; assert (a == b); } } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 218c32a1980..f9e4f94ed80 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -109,9 +109,9 @@ fn run_tests_console(opts: test_opts, te_filtered(filtered_tests) { st.total = vec::len(filtered_tests); let noun = if st.total != 1u { ~"tests" } else { ~"test" }; - st.out.write_line(#fmt["\nrunning %u %s", st.total, noun]); + st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun}); } - te_wait(test) { st.out.write_str(#fmt["test %s ... ", test.name]); } + te_wait(test) { st.out.write_str(fmt!{"test %s ... ", test.name}); } te_result(test, result) { alt st.log_out { some(f) { @@ -146,7 +146,7 @@ fn run_tests_console(opts: test_opts, alt io::file_writer(path, ~[io::create, io::truncate]) { result::ok(w) { some(w) } result::err(s) { - fail(#fmt("can't open output file: %s", s)) + fail(fmt!{"can't open output file: %s", s}) } } } @@ -172,23 +172,23 @@ fn run_tests_console(opts: test_opts, print_failures(st); } - st.out.write_str(#fmt["\nresult: "]); + st.out.write_str(fmt!{"\nresult: "}); if success { // There's no parallelism at this point so it's safe to use color write_ok(st.out, true); } else { write_failed(st.out, true); } - st.out.write_str(#fmt[". %u passed; %u failed; %u ignored\n\n", st.passed, - st.failed, st.ignored]); + st.out.write_str(fmt!{". %u passed; %u failed; %u ignored\n\n", st.passed, + st.failed, st.ignored}); ret success; fn write_log(out: io::writer, result: test_result, test: test_desc) { - out.write_line(#fmt("%s %s", + out.write_line(fmt!{"%s %s", alt result { tr_ok { ~"ok" } tr_failed { ~"failed" } tr_ignored { ~"ignored" } - }, test.name)); + }, test.name}); } fn write_ok(out: io::writer, use_color: bool) { @@ -220,7 +220,7 @@ fn print_failures(st: console_test_state) { let failures = vec::map(failures, |test| test.name); let failures = sort::merge_sort(str::le, failures); for vec::each(failures) |name| { - st.out.write_line(#fmt[" %s", name]); + st.out.write_line(fmt!{" %s", name}); } } @@ -281,7 +281,7 @@ fn run_tests(opts: test_opts, tests: ~[test_desc], // It's tempting to just spawn all the tests at once, but since we have // many tests that run in other processes we would be making a big mess. let concurrency = get_concurrency(); - #debug("using %u test tasks", concurrency); + debug!{"using %u test tasks", concurrency}; let total = vec::len(filtered_tests); let mut run_idx = 0u; diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 8680719c9b9..7cbf16f2ec0 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -200,9 +200,9 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> { if c == ch { ok(next) } else { - err(#fmt("Expected %?, found %?", + err(fmt!{"Expected %?, found %?", str::from_char(c), - str::from_char(ch))) + str::from_char(ch)}) } } @@ -525,7 +525,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> { } '%' { parse_char(s, pos, '%') } ch { - err(#fmt("unknown formatting type: %?", str::from_char(ch))) + err(fmt!{"unknown formatting type: %?", str::from_char(ch)}) } } } @@ -643,70 +643,70 @@ fn strftime(format: ~str, tm: tm) -> ~str { 11 { ~"Dec" } } } - 'C' { #fmt("%02d", (tm.tm_year as int + 1900) / 100) } + 'C' { fmt!{"%02d", (tm.tm_year as int + 1900) / 100} } 'c' { - #fmt("%s %s %s %s %s", + fmt!{"%s %s %s %s %s", parse_type('a', tm), parse_type('b', tm), parse_type('e', tm), parse_type('T', tm), - parse_type('Y', tm)) + parse_type('Y', tm)} } 'D' | 'x' { - #fmt("%s/%s/%s", + fmt!{"%s/%s/%s", parse_type('m', tm), parse_type('d', tm), - parse_type('y', tm)) + parse_type('y', tm)} } - 'd' { #fmt("%02d", tm.tm_mday as int) } - 'e' { #fmt("%2d", tm.tm_mday as int) } + 'd' { fmt!{"%02d", tm.tm_mday as int} } + 'e' { fmt!{"%2d", tm.tm_mday as int} } 'F' { - #fmt("%s-%s-%s", + fmt!{"%s-%s-%s", parse_type('Y', tm), parse_type('m', tm), - parse_type('d', tm)) + parse_type('d', tm)} } //'G' {} //'g' {} - 'H' { #fmt("%02d", tm.tm_hour as int) } + 'H' { fmt!{"%02d", tm.tm_hour as int} } 'I' { let mut h = tm.tm_hour as int; if h == 0 { h = 12 } if h > 12 { h -= 12 } - #fmt("%02d", h) + fmt!{"%02d", h} } - 'j' { #fmt("%03d", tm.tm_yday as int + 1) } - 'k' { #fmt("%2d", tm.tm_hour as int) } + 'j' { fmt!{"%03d", tm.tm_yday as int + 1} } + 'k' { fmt!{"%2d", tm.tm_hour as int} } 'l' { let mut h = tm.tm_hour as int; if h == 0 { h = 12 } if h > 12 { h -= 12 } - #fmt("%2d", h) + fmt!{"%2d", h} } - 'M' { #fmt("%02d", tm.tm_min as int) } - 'm' { #fmt("%02d", tm.tm_mon as int + 1) } + '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" } } 'R' { - #fmt("%s:%s", + fmt!{"%s:%s", parse_type('H', tm), - parse_type('M', tm)) + parse_type('M', tm)} } 'r' { - #fmt("%s:%s:%s %s", + fmt!{"%s:%s:%s %s", parse_type('I', tm), parse_type('M', tm), parse_type('S', tm), - parse_type('p', tm)) + parse_type('p', tm)} } - 'S' { #fmt("%02d", tm.tm_sec as int) } - 's' { #fmt("%d", tm.to_timespec().sec as int) } + 'S' { fmt!{"%02d", tm.tm_sec as int} } + 's' { fmt!{"%d", tm.to_timespec().sec as int} } 'T' | 'X' { - #fmt("%s:%s:%s", + fmt!{"%s:%s:%s", parse_type('H', tm), parse_type('M', tm), - parse_type('S', tm)) + parse_type('S', tm)} } 't' { ~"\t" } //'U' {} @@ -716,24 +716,24 @@ fn strftime(format: ~str, tm: tm) -> ~str { } //'V' {} 'v' { - #fmt("%s-%s-%s", + fmt!{"%s-%s-%s", parse_type('e', tm), parse_type('b', tm), - parse_type('Y', tm)) + parse_type('Y', tm)} } //'W' {} 'w' { int::str(tm.tm_wday as int) } //'X' {} //'x' {} 'Y' { int::str(tm.tm_year as int + 1900) } - 'y' { #fmt("%02d", (tm.tm_year as int + 1900) % 100) } + 'y' { fmt!{"%02d", (tm.tm_year as int + 1900) % 100} } 'Z' { tm.tm_zone } 'z' { let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' }; let mut m = i32::abs(tm.tm_gmtoff) / 60_i32; let h = m / 60_i32; m -= h * 60_i32; - #fmt("%c%02d%02d", sign, h as int, m as int) + fmt!{"%c%02d%02d", sign, h as int, m as int} } //'+' {} '%' { ~"%" } @@ -824,7 +824,7 @@ impl tm for tm { let mut m = i32::abs(self.tm_gmtoff) / 60_i32; let h = m / 60_i32; m -= h * 60_i32; - s + #fmt("%c%02d:%02d", sign, h as int, m as int) + s + fmt!{"%c%02d:%02d", sign, h as int, m as int} } } } @@ -905,7 +905,7 @@ mod tests { let time = { sec: 1234567890_i64, nsec: 54321_i32 }; let local = at(time); - #error("time_at: %?", local); + error!{"time_at: %?", local}; assert local.tm_sec == 30_i32; assert local.tm_min == 31_i32; @@ -1111,7 +1111,7 @@ mod tests { let utc = at_utc(time); let local = at(time); - #error("test_ctime: %? %?", utc.ctime(), local.ctime()); + 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"; diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index b72e2c47539..6b0b4eb2f17 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -106,8 +106,8 @@ fn recv_timeout<T: copy send>(iotask: iotask, // FIXME: This could be written clearer (#2618) either::either( |left_val| { - log(debug, #fmt("recv_time .. left_val %?", - left_val)); + log(debug, fmt!{"recv_time .. left_val %?", + left_val}); none }, |right_val| { some(right_val) @@ -118,7 +118,7 @@ fn recv_timeout<T: copy send>(iotask: iotask, // INTERNAL API extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t, status: libc::c_int) unsafe { - log(debug, #fmt("delayed_send_cb handle %? status %?", handle, status)); + log(debug, fmt!{"delayed_send_cb handle %? status %?", handle, status}); let timer_done_ch = *(uv::ll::get_data_for_uv_handle(handle) as *comm::chan<()>); let stop_result = uv::ll::timer_stop(handle); @@ -134,7 +134,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t, } extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe { - log(debug, #fmt("delayed_send_close_cb handle %?", handle)); + log(debug, fmt!{"delayed_send_close_cb handle %?", handle}); let timer_done_ch = *(uv::ll::get_data_for_uv_handle(handle) as *comm::chan<()>); comm::send(timer_done_ch, ()); diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs index 08096135952..d3b9795b85b 100644 --- a/src/libstd/uv_global_loop.rs +++ b/src/libstd/uv_global_loop.rs @@ -36,43 +36,43 @@ fn get_monitor_task_gl() -> iotask unsafe { let monitor_loop_chan_ptr = rustrt::rust_uv_get_kernel_global_chan_ptr(); - #debug("ENTERING global_loop::get() loop chan: %?", - monitor_loop_chan_ptr); + debug!{"ENTERING global_loop::get() loop chan: %?", + monitor_loop_chan_ptr}; let builder_fn = || { task::task().sched_mode(task::single_threaded).unlinked() }; - #debug("before priv::chan_from_global_ptr"); + debug!{"before priv::chan_from_global_ptr"}; type monchan = chan<iotask>; let monitor_ch = do chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr, builder_fn) |msg_po| { - #debug("global monitor task starting"); + debug!{"global monitor task starting"}; // As a weak task the runtime will notify us when to exit do weaken_task() |weak_exit_po| { - #debug("global monitor task is now weak"); + debug!{"global monitor task is now weak"}; let hl_loop = spawn_loop(); loop { - #debug("in outer_loop..."); + debug!{"in outer_loop..."}; alt select2(weak_exit_po, msg_po) { left(weak_exit) { // all normal tasks have ended, tell the // libuv loop to tear_down, then exit - #debug("weak_exit_po recv'd msg: %?", weak_exit); + debug!{"weak_exit_po recv'd msg: %?", weak_exit}; iotask::exit(hl_loop); break; } right(fetch_ch) { - #debug("hl_loop req recv'd: %?", fetch_ch); + debug!{"hl_loop req recv'd: %?", fetch_ch}; fetch_ch.send(hl_loop); } } } - #debug("global monitor task is leaving weakend state"); + debug!{"global monitor task is leaving weakend state"}; }; - #debug("global monitor task exiting"); + debug!{"global monitor task exiting"}; }; // once we have a chan to the monitor loop, we ask it for @@ -89,14 +89,14 @@ fn spawn_loop() -> iotask unsafe { // The I/O loop task also needs to be weak so it doesn't keep // the runtime alive do weaken_task |weak_exit_po| { - #debug("global libuv task is now weak %?", weak_exit_po); + debug!{"global libuv task is now weak %?", weak_exit_po}; task_body(); // We don't wait for the exit message on weak_exit_po // because the monitor task will tell the uv loop when to // exit - #debug("global libuv task is leaving weakened state"); + debug!{"global libuv task is leaving weakened state"}; } } }; @@ -110,8 +110,8 @@ mod test { timer_ptr as *libc::c_void) as *comm::chan<bool>; let exit_ch = *exit_ch_ptr; comm::send(exit_ch, true); - log(debug, #fmt("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?", - exit_ch_ptr)); + log(debug, fmt!{"EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?", + exit_ch_ptr}); } extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t, _status: libc::c_int) unsafe { @@ -131,8 +131,8 @@ mod test { let exit_po = comm::port::<bool>(); let exit_ch = comm::chan(exit_po); let exit_ch_ptr = ptr::addr_of(exit_ch); - log(debug, #fmt("EXIT_CH_PTR newly created exit_ch_ptr: %?", - exit_ch_ptr)); + log(debug, fmt!{"EXIT_CH_PTR newly created exit_ch_ptr: %?", + exit_ch_ptr}); let timer_handle = ll::timer_t(); let timer_ptr = ptr::addr_of(timer_handle); do iotask::interact(iotask) |loop_ptr| { diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 5566c0c8f0f..bc9878ccc40 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -29,9 +29,9 @@ fn spawn_iotask(-task: task::task_builder) -> iotask { do listen |iotask_ch| { do task.sched_mode(task::single_threaded).spawn { - #debug("entering libuv task"); + debug!{"entering libuv task"}; run_loop(iotask_ch); - #debug("libuv task exiting"); + debug!{"libuv task exiting"}; }; iotask_ch.recv() @@ -136,8 +136,8 @@ fn send_msg(iotask: iotask, extern fn wake_up_cb(async_handle: *ll::uv_async_t, status: int) unsafe { - log(debug, #fmt("wake_up_cb extern.. handle: %? status: %?", - async_handle, status)); + log(debug, fmt!{"wake_up_cb extern.. handle: %? status: %?", + async_handle, status}); let loop_ptr = ll::get_loop_for_uv_handle(async_handle); let data = ll::get_data_for_uv_handle(async_handle) as *iotask_loop_data; @@ -164,22 +164,22 @@ fn begin_teardown(data: *iotask_loop_data) unsafe { extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe { let loop_ptr = ll::get_loop_for_uv_handle(handle); let loop_refs = ll::loop_refcount(loop_ptr); - log(debug, #fmt("tear_down_close_cb called, closing handle at %? refs %?", - handle, loop_refs)); + log(debug, fmt!{"tear_down_close_cb called, closing handle at %? refs %?", + handle, loop_refs}); assert loop_refs == 1i32; } #[cfg(test)] mod test { extern fn async_close_cb(handle: *ll::uv_async_t) unsafe { - log(debug, #fmt("async_close_cb handle %?", handle)); + log(debug, fmt!{"async_close_cb handle %?", handle}); let exit_ch = (*(ll::get_data_for_uv_handle(handle) as *ah_data)).exit_ch; comm::send(exit_ch, ()); } extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int) unsafe { - log(debug, #fmt("async_handle_cb handle %? status %?",handle,status)); + log(debug, fmt!{"async_handle_cb handle %? status %?",handle,status}); ll::close(handle, async_close_cb); } type ah_data = { @@ -217,13 +217,13 @@ mod test { } extern fn lifetime_handle_close(handle: *libc::c_void) unsafe { - log(debug, #fmt("lifetime_handle_close ptr %?", handle)); + log(debug, fmt!{"lifetime_handle_close ptr %?", handle}); } extern fn lifetime_async_callback(handle: *libc::c_void, status: libc::c_int) { - log(debug, #fmt("lifetime_handle_close ptr %? status %?", - handle, status)); + log(debug, fmt!{"lifetime_handle_close ptr %? status %?", + handle, status}); } #[test] diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index cb1f5321f78..96c3b5b1609 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -705,8 +705,8 @@ unsafe fn tcp_connect(connect_ptr: *uv_connect_t, addr_ptr: *sockaddr_in, ++after_connect_cb: *u8) -> libc::c_int { - log(debug, #fmt("b4 foreign tcp_connect--addr port: %u cb: %u", - (*addr_ptr).sin_port as uint, after_connect_cb as uint)); + log(debug, fmt!{"b4 foreign tcp_connect--addr port: %u cb: %u", + (*addr_ptr).sin_port as uint, after_connect_cb as uint}); ret rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr); } @@ -786,10 +786,10 @@ unsafe fn async_send(async_handle: *uv_async_t) { unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t { let out_buf = { base: ptr::null(), len: 0 as libc::size_t }; let out_buf_ptr = ptr::addr_of(out_buf); - log(debug, #fmt("buf_init - input %u len %u out_buf: %u", + log(debug, fmt!{"buf_init - input %u len %u out_buf: %u", input as uint, len as uint, - out_buf_ptr as uint)); + out_buf_ptr as uint}); // 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); @@ -797,9 +797,9 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t { 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); - log(debug, #fmt("buf_init - result %u len %u", + log(debug, fmt!{"buf_init - result %u len %u", res_base as uint, - res_len as uint)); + res_len as uint}); ret out_buf; //ret result; } @@ -843,8 +843,8 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str { 0u8,0u8,0u8,0u8,0u8,0u8]; do vec::as_buf(dst) |dst_buf, size| { let src_unsafe_ptr = src as *sockaddr_in6; - log(debug, #fmt("val of src *sockaddr_in6: %? sockaddr_in6: %?", - src_unsafe_ptr, src)); + log(debug, fmt!{"val of src *sockaddr_in6: %? sockaddr_in6: %?", + src_unsafe_ptr, src}); let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr, dst_buf, size as libc::size_t); alt result { @@ -964,8 +964,8 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str { let err_ptr = ptr::addr_of(err); let err_name = str::unsafe::from_c_str(err_name(err_ptr)); let err_msg = str::unsafe::from_c_str(strerror(err_ptr)); - ret #fmt("LIBUV ERROR: name: %s msg: %s", - err_name, err_msg); + ret fmt!{"LIBUV ERROR: name: %s msg: %s", + err_name, err_msg}; } unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data { @@ -1015,8 +1015,8 @@ mod test { }; extern fn after_close_cb(handle: *libc::c_void) { - log(debug, #fmt("after uv_close! handle ptr: %?", - handle)); + log(debug, fmt!{"after uv_close! handle ptr: %?", + handle}); } extern fn on_alloc_cb(handle: *libc::c_void, @@ -1024,10 +1024,10 @@ mod test { -> uv_buf_t unsafe { 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", + log(debug, fmt!{"on_alloc_cb h: %? char_ptr: %u sugsize: %u", handle, char_ptr as uint, - suggested_size as uint)); + suggested_size as uint}); ret buf_init(char_ptr, suggested_size as uint); } @@ -1035,11 +1035,11 @@ mod test { nread: libc::ssize_t, ++buf: uv_buf_t) unsafe { let nread = nread as int; - log(debug, #fmt("CLIENT entering on_read_cb nred: %d", - nread)); + log(debug, fmt!{"CLIENT entering on_read_cb nred: %d", + nread}); if (nread > 0) { // we have data - log(debug, #fmt("CLIENT read: data! nread: %d", nread)); + log(debug, fmt!{"CLIENT read: data! nread: %d", nread}); read_stop(stream); let client_data = get_data_for_uv_handle(stream as *libc::c_void) @@ -1067,20 +1067,20 @@ mod test { extern fn on_write_complete_cb(write_req: *uv_write_t, status: libc::c_int) unsafe { - log(debug, #fmt("CLIENT beginning on_write_complete_cb status: %d", - status as int)); + log(debug, fmt!{"CLIENT beginning on_write_complete_cb status: %d", + status as int}); let stream = get_stream_handle_from_write_req(write_req); - log(debug, #fmt("CLIENT on_write_complete_cb: tcp:%d write_handle:%d", - stream as int, write_req as int)); + log(debug, fmt!{"CLIENT on_write_complete_cb: tcp:%d write_handle:%d", + stream as int, write_req as int}); let result = read_start(stream, on_alloc_cb, on_read_cb); - log(debug, #fmt("CLIENT ending on_write_complete_cb .. status: %d", - result as int)); + log(debug, fmt!{"CLIENT ending on_write_complete_cb .. status: %d", + result as int}); } extern fn on_connect_cb(connect_req_ptr: *uv_connect_t, status: libc::c_int) unsafe { - log(debug, #fmt("beginning on_connect_cb .. status: %d", - status as int)); + log(debug, fmt!{"beginning on_connect_cb .. status: %d", + status as int}); let stream = get_stream_handle_from_connect_req(connect_req_ptr); if (status == 0i32) { @@ -1089,14 +1089,14 @@ mod test { connect_req_ptr as *libc::c_void) as *request_wrapper; let write_handle = (*client_data).write_req; - log(debug, #fmt("on_connect_cb: tcp: %d write_hdl: %d", - stream as int, write_handle as int)); + log(debug, fmt!{"on_connect_cb: tcp: %d write_hdl: %d", + stream as int, write_handle as int}); let write_result = write(write_handle, stream as *libc::c_void, (*client_data).req_buf, on_write_complete_cb); - log(debug, #fmt("on_connect_cb: write() status: %d", - write_result as int)); + log(debug, fmt!{"on_connect_cb: write() status: %d", + write_result as int}); } else { let test_loop = get_loop_for_uv_handle( @@ -1123,7 +1123,7 @@ mod test { // data field in our uv_connect_t struct let req_str_bytes = str::bytes(req_str); let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes); - log(debug, #fmt("req_msg ptr: %u", req_msg_ptr as uint)); + log(debug, fmt!{"req_msg ptr: %u", req_msg_ptr as uint}); let req_msg = ~[ buf_init(req_msg_ptr, vec::len(req_str_bytes)) ]; @@ -1131,9 +1131,9 @@ mod test { // this to C.. let write_handle = write_t(); let write_handle_ptr = ptr::addr_of(write_handle); - log(debug, #fmt("tcp req: tcp stream: %d write_handle: %d", + log(debug, fmt!{"tcp req: tcp stream: %d write_handle: %d", tcp_handle_ptr as int, - write_handle_ptr as int)); + write_handle_ptr as int}); let client_data = { writer_handle: write_handle_ptr, req_buf: ptr::addr_of(req_msg), read_chan: client_chan }; @@ -1147,12 +1147,12 @@ mod test { let addr = ip4_addr(ip, port); // FIXME ref #2064 let addr_ptr = ptr::addr_of(addr); - log(debug, #fmt("after build addr in rust. port: %u", - addr.sin_port as uint)); + log(debug, fmt!{"after build addr in rust. port: %u", + addr.sin_port as uint}); // this should set up the connection request.. - log(debug, #fmt("b4 call tcp_connect connect cb: %u ", - on_connect_cb as uint)); + log(debug, fmt!{"b4 call tcp_connect connect cb: %u ", + on_connect_cb as uint}); let tcp_connect_result = tcp_connect( connect_req_ptr, tcp_handle_ptr, addr_ptr, on_connect_cb); @@ -1183,8 +1183,8 @@ mod test { } extern fn server_after_close_cb(handle: *libc::c_void) unsafe { - log(debug, #fmt("SERVER server stream closed, should exit.. h: %?", - handle)); + log(debug, fmt!{"SERVER server stream closed, should exit.. h: %?", + handle}); } extern fn client_stream_after_close_cb(handle: *libc::c_void) @@ -1212,15 +1212,15 @@ mod test { let nread = nread as int; if (nread > 0) { // we have data - log(debug, #fmt("SERVER read: data! nread: %d", nread)); + log(debug, fmt!{"SERVER read: data! nread: %d", nread}); // pull out the contents of the write from the client let buf_base = get_base_from_buf(buf); let buf_len = get_len_from_buf(buf) as uint; - log(debug, #fmt("SERVER buf base: %u, len: %u, nread: %d", + log(debug, fmt!{"SERVER buf base: %u, len: %u, nread: %d", buf_base as uint, buf_len as uint, - nread)); + nread}); let bytes = vec::unsafe::from_buf(buf_base, buf_len); let request_str = str::from_bytes(bytes); @@ -1240,8 +1240,8 @@ mod test { client_stream_ptr as *libc::c_void, (*client_data).server_resp_buf, after_server_resp_write); - log(debug, #fmt("SERVER: resp write result: %d", - write_result as int)); + 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, get_last_err_info( @@ -1275,8 +1275,8 @@ mod test { server_stream_ptr as *libc::c_void); if status != 0i32 { let err_msg = get_last_err_info(test_loop); - log(debug, #fmt("server_connect_cb: non-zero status: %?", - err_msg)); + log(debug, fmt!{"server_connect_cb: non-zero status: %?", + err_msg}); ret; } let server_data = get_data_for_uv_handle( @@ -1303,20 +1303,20 @@ mod test { log(debug, ~"successful server read start"); } else { - log(debug, #fmt("server_connection_cb: bad read:%d", - read_result as int)); + log(debug, fmt!{"server_connection_cb: bad read:%d", + read_result as int}); assert false; } } else { - log(debug, #fmt("server_connection_cb: bad accept: %d", - accept_result as int)); + log(debug, fmt!{"server_connection_cb: bad accept: %d", + accept_result as int}); assert false; } } else { - log(debug, #fmt("server_connection_cb: bad client init: %d", - client_init_result as int)); + log(debug, fmt!{"server_connection_cb: bad client init: %d", + client_init_result as int}); assert false; } } @@ -1335,8 +1335,8 @@ mod test { }; extern fn async_close_cb(handle: *libc::c_void) { - log(debug, #fmt("SERVER: closing async cb... h: %?", - handle)); + log(debug, fmt!{"SERVER: closing async cb... h: %?", + handle}); } extern fn continue_async_cb(async_handle: *uv_async_t, @@ -1371,7 +1371,7 @@ mod test { let resp_str_bytes = str::bytes(server_resp_msg); let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes); - log(debug, #fmt("resp_msg ptr: %u", resp_msg_ptr as uint)); + log(debug, fmt!{"resp_msg ptr: %u", resp_msg_ptr as uint}); let resp_msg = ~[ buf_init(resp_msg_ptr, vec::len(resp_str_bytes)) ]; @@ -1430,26 +1430,26 @@ mod test { log(debug, ~"server uv::run() has returned"); } else { - log(debug, #fmt("uv_async_init failure: %d", - async_result as int)); + log(debug, fmt!{"uv_async_init failure: %d", + async_result as int}); assert false; } } else { - log(debug, #fmt("non-zero result on uv_listen: %d", - listen_result as int)); + log(debug, fmt!{"non-zero result on uv_listen: %d", + listen_result as int}); assert false; } } else { - log(debug, #fmt("non-zero result on uv_tcp_bind: %d", - bind_result as int)); + log(debug, fmt!{"non-zero result on uv_tcp_bind: %d", + bind_result as int}); assert false; } } else { - log(debug, #fmt("non-zero result on uv_tcp_init: %d", - tcp_init_result as int)); + log(debug, fmt!{"non-zero result on uv_tcp_init: %d", + tcp_init_result as int}); assert false; } loop_delete(test_loop); @@ -1526,8 +1526,8 @@ mod test { fn test_uv_ll_struct_size_uv_tcp_t() { let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size(); let rust_handle_size = sys::size_of::<uv_tcp_t>(); - let output = #fmt("uv_tcp_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_tcp_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1537,8 +1537,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_connect_t_size(); let rust_handle_size = sys::size_of::<uv_connect_t>(); - let output = #fmt("uv_connect_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_connect_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1548,8 +1548,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_buf_t_size(); let rust_handle_size = sys::size_of::<uv_buf_t>(); - let output = #fmt("uv_buf_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_buf_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1559,8 +1559,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_write_t_size(); let rust_handle_size = sys::size_of::<uv_write_t>(); - let output = #fmt("uv_write_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_write_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1571,8 +1571,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_sockaddr_in_size(); let rust_handle_size = sys::size_of::<sockaddr_in>(); - let output = #fmt("sockaddr_in -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"sockaddr_in -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1582,8 +1582,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_sockaddr_in6_size(); let rust_handle_size = sys::size_of::<sockaddr_in6>(); - let output = #fmt("sockaddr_in6 -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"sockaddr_in6 -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); // FIXME #1645 .. rust appears to pad structs to the nearest byte..? // .. can't get the uv::ll::sockaddr_in6 to == 28 :/ @@ -1597,8 +1597,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_addr_in_size(); let rust_handle_size = sys::size_of::<addr_in>(); - let output = #fmt("addr_in -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"addr_in -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); // FIXME #1645 .. see note above about struct padding assert (4u+foreign_handle_size as uint) == rust_handle_size; @@ -1610,8 +1610,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_async_t_size(); let rust_handle_size = sys::size_of::<uv_async_t>(); - let output = #fmt("uv_async_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_async_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1622,8 +1622,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_timer_t_size(); let rust_handle_size = sys::size_of::<uv_timer_t>(); - let output = #fmt("uv_timer_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_timer_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1635,8 +1635,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_uv_getaddrinfo_t_size(); let rust_handle_size = sys::size_of::<uv_getaddrinfo_t>(); - let output = #fmt("uv_getaddrinfo_t -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"uv_getaddrinfo_t -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } @@ -1648,8 +1648,8 @@ mod test { let foreign_handle_size = rustrt::rust_uv_helper_addrinfo_size(); let rust_handle_size = sys::size_of::<addrinfo>(); - let output = #fmt("addrinfo -- foreign: %u rust: %u", - foreign_handle_size as uint, rust_handle_size); + let output = fmt!{"addrinfo -- foreign: %u rust: %u", + foreign_handle_size as uint, rust_handle_size}; log(debug, output); assert foreign_handle_size as uint == rust_handle_size; } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 4820ac2f4a9..ebe7a7eb36a 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -24,7 +24,7 @@ fn path_ident_to_str(p: path, i: ident) -> ~str { if vec::is_empty(p) { /* FIXME (#2543) */ copy *i } else { - #fmt["%s::%s", path_to_str(p), *i] + fmt!{"%s::%s", path_to_str(p), *i} } } @@ -270,46 +270,46 @@ fn map_expr(ex: @expr, cx: ctx, v: vt) { fn node_id_to_str(map: map, id: node_id) -> ~str { alt map.find(id) { none { - #fmt["unknown node (id=%d)", id] + fmt!{"unknown node (id=%d)", id} } some(node_item(item, path)) { - #fmt["item %s (id=%?)", path_ident_to_str(*path, item.ident), id] + fmt!{"item %s (id=%?)", path_ident_to_str(*path, item.ident), id} } some(node_foreign_item(item, abi, path)) { - #fmt["foreign item %s with abi %? (id=%?)", - path_ident_to_str(*path, item.ident), abi, id] + fmt!{"foreign item %s with abi %? (id=%?)", + path_ident_to_str(*path, item.ident), abi, id} } some(node_method(m, impl_did, path)) { - #fmt["method %s in %s (id=%?)", - *m.ident, path_to_str(*path), id] + fmt!{"method %s in %s (id=%?)", + *m.ident, path_to_str(*path), id} } some(node_variant(variant, def_id, path)) { - #fmt["variant %s in %s (id=%?)", - *variant.node.name, path_to_str(*path), id] + fmt!{"variant %s in %s (id=%?)", + *variant.node.name, path_to_str(*path), id} } some(node_expr(expr)) { - #fmt["expr %s (id=%?)", - pprust::expr_to_str(expr), id] + fmt!{"expr %s (id=%?)", + pprust::expr_to_str(expr), id} } // FIXMEs are as per #2410 some(node_export(_, path)) { - #fmt["export %s (id=%?)", // add more info here - path_to_str(*path), id] + fmt!{"export %s (id=%?)", // add more info here + path_to_str(*path), id} } some(node_arg(_, _)) { // add more info here - #fmt["arg (id=%?)", id] + fmt!{"arg (id=%?)", id} } some(node_local(_)) { // add more info here - #fmt["local (id=%?)", id] + fmt!{"local (id=%?)", id} } some(node_ctor(*)) { // add more info here - #fmt["node_ctor (id=%?)", id] + fmt!{"node_ctor (id=%?)", id} } some(node_dtor(*)) { // add more info here - #fmt["node_dtor (id=%?)", id] + fmt!{"node_dtor (id=%?)", id} } some(node_block(_)) { - #fmt["block"] + fmt!{"block"} } } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 4587a5b8b29..5801bc895e5 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -197,12 +197,12 @@ fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: ~str) -> * comparison is performed structurally. */ fn contains(haystack: ~[@ast::meta_item], needle: @ast::meta_item) -> bool { - #debug("looking for %s", - print::pprust::meta_item_to_str(*needle)); + debug!{"looking for %s", + print::pprust::meta_item_to_str(*needle)}; for haystack.each |item| { - #debug("looking in %s", - print::pprust::meta_item_to_str(*item)); - if eq(item, needle) { #debug("found it!"); ret true; } + debug!{"looking in %s", + print::pprust::meta_item_to_str(*item)}; + if eq(item, needle) { debug!{"found it!"}; ret true; } } #debug("found it not :("); ret false; @@ -323,7 +323,7 @@ fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] { 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"); } + _ { debug!{"ignoring link attribute that has incorrect type"}; } } } ret found; @@ -399,7 +399,7 @@ fn require_unique_names(diagnostic: span_handler, // FIXME: How do I silence the warnings? --pcw (#2619) if map.contains_key(*name) { diagnostic.span_fatal(meta.span, - #fmt["duplicate meta item `%s`", *name]); + fmt!{"duplicate meta item `%s`", *name}); } map.insert(*name, ()); } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 76625d3f918..0c211395223 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -73,7 +73,7 @@ fn new_filemap(+filename: filename, src: @~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); + ret fmt!{"<%s:%u:%u>", pos.file.name, pos.line, pos.col}; } fn next_line(file: filemap, chpos: uint, byte_pos: uint) { @@ -93,7 +93,7 @@ fn lookup_line(map: codemap, pos: uint, lookup: lookup_fn) if lookup(map.files[m].start_pos) > pos { b = m; } else { a = m; } } if (a >= len) { - fail #fmt("position %u does not resolve to a source location", pos) + fail fmt!{"position %u does not resolve to a source location", pos} } let f = map.files[a]; a = 0u; @@ -166,15 +166,15 @@ type span = {lo: uint, hi: uint, expn_info: expn_info}; 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) + 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 { 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, - lo.line, lo.col, hi.line, hi.col) + ret fmt!{"%s:%u:%u: %u:%u", lo.filename, + lo.line, lo.col, hi.line, hi.col} } type file_lines = {file: filemap, lines: ~[uint]}; diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 6178dfb616e..4a6935f7fc8 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -90,8 +90,8 @@ impl codemap_handler of handler for handler_t { alt self.err_count { 0u { ret; } 1u { s = ~"aborting due to previous error"; } - _ { s = #fmt["aborting due to %u previous errors", - self.err_count]; } + _ { s = fmt!{"aborting due to %u previous errors", + self.err_count}; } } self.fatal(s); } @@ -111,7 +111,7 @@ impl codemap_handler of handler for handler_t { } fn ice_msg(msg: ~str) -> ~str { - #fmt["internal compiler error: %s", msg] + fmt!{"internal compiler error: %s", msg} } fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler { @@ -166,16 +166,16 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) { let use_color = term::color_supported() && io::stderr().get_type() == io::screen; if str::is_not_empty(topic) { - io::stderr().write_str(#fmt["%s ", topic]); + io::stderr().write_str(fmt!{"%s ", topic}); } if use_color { term::fg(io::stderr(), diagnosticcolor(lvl)); } - io::stderr().write_str(#fmt["%s:", diagnosticstr(lvl)]); + io::stderr().write_str(fmt!{"%s:", diagnosticstr(lvl)}); if use_color { term::reset(io::stderr()); } - io::stderr().write_str(#fmt[" %s\n", msg]); + io::stderr().write_str(fmt!{" %s\n", msg}); } fn emit(cmsp: option<(codemap::codemap, span)>, @@ -210,13 +210,13 @@ 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]); + io::stderr().write_str(fmt!{"%s:%u ", fm.name, line + 1u}); 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 s = fmt!{"%s:%u ", fm.name, last_line + 1u}; let mut indent = str::len(s); let mut out = ~""; while indent > 0u { out += ~" "; indent -= 1u; } @@ -255,7 +255,7 @@ fn print_macro_backtrace(cm: codemap::codemap, sp: 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)); + 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_macro_backtrace(cm, ei.call_site); diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs index c52617c74bf..57b6dc13b8a 100644 --- a/src/libsyntax/ext/auto_serialize.rs +++ b/src/libsyntax/ext/auto_serialize.rs @@ -348,7 +348,7 @@ fn ser_variant(cx: ext_ctxt, argfn: fn(-@ast::expr, uint, ast::blk) -> @ast::expr) -> ast::arm { let vnames = do vec::from_fn(vec::len(tys)) |i| { - @#fmt["__v%u", i] + @fmt!{"__v%u", i} }; let pats = do vec::from_fn(vec::len(tys)) |i| { cx.binder_pat(tys[i].span, vnames[i]) @@ -398,13 +398,13 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, ast::ty_bot { cx.span_err( - ty.span, #fmt["Cannot serialize bottom type"]); + ty.span, fmt!{"Cannot serialize bottom type"}); ~[] } ast::ty_box(mt) { let l = ser_lambda(cx, tps, mt.ty, cx.clone(s), #ast{ *$(v) }); - ~[#ast(stmt){$(s).emit_box($(l));}] + ~[#ast[stmt]{$(s).emit_box($(l));}] } // For unique evecs/estrs, just pass through to underlying vec or str @@ -414,7 +414,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, ast::ty_uniq(mt) { let l = ser_lambda(cx, tps, mt.ty, cx.clone(s), #ast{ *$(v) }); - ~[#ast(stmt){$(s).emit_uniq($(l));}] + ~[#ast[stmt]{$(s).emit_uniq($(l));}] } ast::ty_ptr(_) | ast::ty_rptr(_, _) { @@ -433,10 +433,10 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, let f = cx.lit_str(fld.span, fld.node.ident); let i = cx.lit_uint(fld.span, fidx); let l = ser_lambda(cx, tps, fld.node.mt.ty, cx.clone(s), vf); - #ast(stmt){$(s).emit_rec_field($(f), $(i), $(l));} + #ast[stmt]{$(s).emit_rec_field($(f), $(i), $(l));} }; let fld_lambda = cx.lambda(cx.blk(ty.span, fld_stmts)); - ~[#ast(stmt){$(s).emit_rec($(fld_lambda));}] + ~[#ast[stmt]{$(s).emit_rec($(fld_lambda));}] } ast::ty_fn(_, _) { @@ -514,7 +514,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, cx.clone(s), cx.at(ty.span, #ast{ __e }))))); - ~[#ast(stmt){ + ~[#ast[stmt]{ std::serialization::emit_from_vec($(s), $(v), |__e| $(ser_e)) }] } @@ -544,7 +544,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, ident: @(~"__s" + *tp.ident), id: cx.next_id()}); - #debug["tp_inputs = %?", tp_inputs]; + debug!{"tp_inputs = %?", tp_inputs}; let ser_inputs: ~[ast::arg] = @@ -565,8 +565,8 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, *tp.ident, fn@(v: @ast::expr) -> ~[@ast::stmt] { let f = cx.var_ref(span, arg_ident); - #debug["serializing type arg %s", *arg_ident]; - ~[#ast(stmt){$(f)($(v));}] + debug!{"serializing type arg %s", *arg_ident}; + ~[#ast[stmt]{$(f)($(v));}] }); } @@ -755,7 +755,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span, ident: @(~"__d" + *tp.ident), id: cx.next_id()}); - #debug["tp_inputs = %?", tp_inputs]; + debug!{"tp_inputs = %?", tp_inputs}; let deser_inputs: ~[ast::arg] = vec::append(~[{mode: ast::expl(ast::by_ref), @@ -792,7 +792,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span, with cloned} })); - let deser_blk = cx.expr_blk(f(cx, tps_map, #ast(expr){__d})); + let deser_blk = cx.expr_blk(f(cx, tps_map, #ast[expr]{__d})); @{ident: @(~"deserialize_" + *name), attrs: ~[], @@ -864,7 +864,7 @@ fn ser_enum(cx: ext_ctxt, tps: ser_tps_map, e_name: ast::ident, }; let lam = cx.lambda(cx.blk(e_span, ~[cx.alt_stmt(arms, e_span, v)])); let e_name = cx.lit_str(e_span, e_name); - ~[#ast(stmt){ $(s).emit_enum($(e_name), $(lam)) }] + ~[#ast[stmt]{ $(s).emit_enum($(e_name), $(lam)) }] } fn deser_enum(cx: ext_ctxt, tps: deser_tps_map, e_name: ast::ident, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 4a2bdf4cde5..c6889eb9c1d 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -243,22 +243,22 @@ fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg, alt max { some(max) if ! (min <= elts_len && elts_len <= max) { cx.span_fatal(sp, - #fmt["#%s takes between %u and %u arguments.", - name, min, max]); + fmt!{"#%s takes between %u and %u arguments.", + name, min, max}); } none if ! (min <= elts_len) { - cx.span_fatal(sp, #fmt["#%s needs at least %u arguments.", - name, min]); + cx.span_fatal(sp, fmt!{"#%s needs at least %u arguments.", + name, min}); } _ { ret elts; /* we're good */} } } _ { - cx.span_fatal(sp, #fmt["#%s: malformed invocation", name]) + cx.span_fatal(sp, fmt!{"#%s: malformed invocation", name}) } } } - none {cx.span_fatal(sp, #fmt["#%s: missing arguments", name])} + none {cx.span_fatal(sp, fmt!{"#%s: missing arguments", name})} } } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 38d6477a2f9..3805f1a19c6 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -29,12 +29,12 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, alt exts.find(*extname) { none { cx.span_fatal(pth.span, - #fmt["macro undefined: '%s'", *extname]) + fmt!{"macro undefined: '%s'", *extname}) } some(item_decorator(_)) { cx.span_fatal( pth.span, - #fmt["%s can only be used as a decorator", *extname]); + fmt!{"%s can only be used as a decorator", *extname}); } some(normal({expander: exp, span: exp_sp})) { let expanded = exp(cx, mac.span, args, body); @@ -54,8 +54,8 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, } some(expr_tt(_)) { cx.span_fatal(pth.span, - #fmt["this tt-style macro should be \ - invoked '%s!{...}'", *extname]) + fmt!{"this tt-style macro should be \ + invoked '%s!{...}'", *extname}) } some(item_tt(*)) { cx.span_fatal(pth.span, @@ -72,14 +72,14 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, alt exts.find(*extname) { none { cx.span_fatal(pth.span, - #fmt["macro undefined: '%s'", *extname]) + fmt!{"macro undefined: '%s'", *extname}) } some(expr_tt({expander: exp, span: exp_sp})) { let expanded = alt exp(cx, mac.span, tts) { mr_expr(e) { e } _ { cx.span_fatal( - pth.span, #fmt["non-expr macro in expr pos: %s", - *extname]) } + pth.span, fmt!{"non-expr macro in expr pos: %s", + *extname}) } }; cx.bt_push(expanded_from({call_site: s, @@ -106,8 +106,8 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, } _ { cx.span_fatal(pth.span, - #fmt["'%s' is not a tt-style macro", - *extname]) + fmt!{"'%s' is not a tt-style macro", + *extname}) } } @@ -203,7 +203,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>, alt exts.find(*extname) { none { cx.span_fatal(pth.span, - #fmt("macro undefined: '%s'", *extname)) + fmt!{"macro undefined: '%s'", *extname}) } some(item_tt(expand)) { let expanded = expand.expander(cx, it.span, it.ident, tts); @@ -224,7 +224,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>, ret maybe_it } _ { cx.span_fatal(it.span, - #fmt("%s is not a legal here", *extname)) } + fmt!{"%s is not a legal here", *extname}) } } } _ { @@ -246,10 +246,10 @@ fn new_span(cx: ext_ctxt, sp: span) -> span { 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, ...])]); - #macro([#debug[f, ...], log(core::debug, #fmt[f, ...])]); + #macro[[#error[f, ...], log(core::error, #fmt[f, ...])]]; + #macro[[#warn[f, ...], log(core::warn, #fmt[f, ...])]]; + #macro[[#info[f, ...], log(core::info, #fmt[f, ...])]]; + #macro[[#debug[f, ...], log(core::debug, #fmt[f, ...])]]; }"; } diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs index 53b5db8b6a6..d8549ca21c8 100644 --- a/src/libsyntax/ext/fmt.rs +++ b/src/libsyntax/ext/fmt.rs @@ -18,7 +18,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg, expr_to_str(cx, args[0], ~"first argument to #fmt must be a string literal."); let fmtspan = args[0].span; - #debug("Format string:"); + debug!{"Format string:"}; log(debug, fmt); fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: ~str) -> ! { cx.span_fatal(sp, msg); @@ -189,15 +189,15 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, fn log_conv(c: conv) { alt c.param { some(p) { log(debug, ~"param: " + int::to_str(p, 10u)); } - _ { #debug("param: none"); } + _ { debug!{"param: none"}; } } for c.flags.each |f| { alt f { - flag_left_justify { #debug("flag: left justify"); } - flag_left_zero_pad { #debug("flag: left zero pad"); } - flag_space_for_sign { #debug("flag: left space pad"); } - flag_sign_always { #debug("flag: sign always"); } - flag_alternate { #debug("flag: alternate"); } + flag_left_justify { debug!{"flag: left justify"}; } + flag_left_zero_pad { debug!{"flag: left zero pad"}; } + flag_space_for_sign { debug!{"flag: left space pad"}; } + flag_sign_always { debug!{"flag: sign always"}; } + flag_alternate { debug!{"flag: alternate"}; } } } alt c.width { @@ -207,8 +207,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, log(debug, ~"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"); } + 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, @@ -217,29 +217,29 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, log(debug, ~"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"); } + count_is_next_param { debug!{"prec: count is next param"}; } + count_implied { debug!{"prec: count is implied"}; } } alt c.ty { - ty_bool { #debug("type: bool"); } - ty_str { #debug("type: str"); } - ty_char { #debug("type: char"); } + ty_bool { debug!{"type: bool"}; } + ty_str { debug!{"type: str"}; } + ty_char { debug!{"type: char"}; } ty_int(s) { alt s { - signed { #debug("type: signed"); } - unsigned { #debug("type: unsigned"); } + signed { debug!{"type: signed"}; } + unsigned { debug!{"type: unsigned"}; } } } - ty_bits { #debug("type: bits"); } + ty_bits { debug!{"type: bits"}; } ty_hex(cs) { alt cs { - case_upper { #debug("type: uhex"); } - case_lower { #debug("type: lhex"); } + case_upper { debug!{"type: uhex"}; } + case_lower { debug!{"type: lhex"}; } } } - ty_octal { #debug("type: octal"); } - ty_float { #debug("type: float"); } - ty_poly { #debug("type: poly"); } + ty_octal { debug!{"type: octal"}; } + ty_float { debug!{"type: float"}; } + ty_poly { debug!{"type: poly"}; } } } let fmt_sp = args[0].span; @@ -258,7 +258,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, ~"not enough arguments to #fmt " + ~"for the given format string"); } - #debug("Building conversion:"); + debug!{"Building conversion:"}; log_conv(conv); let arg_expr = args[n]; let c_expr = make_new_conv(cx, fmt_sp, conv, arg_expr); @@ -270,8 +270,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, if expected_nargs < nargs { cx.span_fatal - (sp, #fmt["too many arguments to #fmt. found %u, expected %u", - nargs, expected_nargs]); + (sp, fmt!{"too many arguments to #fmt. found %u, expected %u", + nargs, expected_nargs}); } let arg_vec = mk_fixed_vec_e(cx, fmt_sp, piece_exprs); diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs index 2988b8eaeb1..24ac18ada6a 100644 --- a/src/libsyntax/ext/pipes/check.rs +++ b/src/libsyntax/ext/pipes/check.rs @@ -36,9 +36,9 @@ impl proto_check of proto::visitor<(), (), ()> for ext_ctxt { if state.messages.len() == 0 { self.span_warn( state.span, // use a real span! - #fmt("state %s contains no messages, \ + fmt!{"state %s contains no messages, \ consider stepping to a terminal state instead", - *state.name)) + *state.name}) } } @@ -52,8 +52,8 @@ impl proto_check of proto::visitor<(), (), ()> for ext_ctxt { // track span information. self.span_err( proto.get_state(next).span, - #fmt("message %s steps to undefined state, %s", - *name, *next)); + fmt!{"message %s steps to undefined state, %s", + *name, *next}); } else { let next = proto.get_state(next); @@ -61,11 +61,11 @@ impl proto_check of proto::visitor<(), (), ()> for ext_ctxt { if next.ty_params.len() != next_tys.len() { self.span_err( next.span, // use a real span - #fmt("message %s target (%s) \ + fmt!{"message %s target (%s) \ needs %u type parameters, but got %u", *name, *next.name, next.ty_params.len(), - next_tys.len())); + next_tys.len()}); } } } diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs index c3ae0fb80fd..87179accefa 100644 --- a/src/libsyntax/ext/pipes/liveness.rs +++ b/src/libsyntax/ext/pipes/liveness.rs @@ -35,7 +35,7 @@ import proto::methods; import ast_builder::empty_span; fn analyze(proto: protocol, _cx: ext_ctxt) { - #debug("initializing colive analysis"); + debug!{"initializing colive analysis"}; let num_states = proto.num_states(); let colive = do (copy proto.states).map_to_vec |state| { let bv = ~bitv(num_states, false); @@ -49,7 +49,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) { let mut changed = true; while changed { changed = false; - #debug("colive iteration %?", i); + debug!{"colive iteration %?", i}; for colive.eachi |i, this_colive| { let this = proto.get_state_by_id(i); for this_colive.ones |j| { @@ -62,7 +62,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) { i += 1; } - #debug("colive analysis complete"); + debug!{"colive analysis complete"}; // Determine if we're bounded let mut self_live = ~[]; @@ -75,20 +75,20 @@ fn analyze(proto: protocol, _cx: ext_ctxt) { if self_live.len() > 0 { let states = str::connect(self_live.map(|s| *s.name), ~" "); - #debug("protocol %s is unbounded due to loops involving: %s", - *proto.name, states); + debug!{"protocol %s is unbounded due to loops involving: %s", + *proto.name, states}; // Someday this will be configurable with a warning //cx.span_warn(empty_span(), - // #fmt("protocol %s is unbounded due to loops \ + // fmt!{"protocol %s is unbounded due to loops \ // involving these states: %s", // *proto.name, - // states)); + // states}); proto.bounded = some(false); } else { - #debug("protocol %s is bounded. yay!", *proto.name); + debug!{"protocol %s is bounded. yay!", *proto.name}; proto.bounded = some(true); } } \ No newline at end of file diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index c5a56cac1f2..32df5ed472a 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -46,10 +46,10 @@ trait gen_init { impl compile of gen_send for message { fn gen_send(cx: ext_ctxt) -> @ast::item { - #debug("pipec: gen_send"); + debug!{"pipec: gen_send"}; alt self { message(id, span, tys, this, some({state: next, tys: next_tys})) { - #debug("pipec: next state exists"); + debug!{"pipec: next state exists"}; 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())); @@ -78,12 +78,12 @@ impl compile of gen_send for message { }; body += "let b = pipe.reuse_buffer();\n"; - body += #fmt("let %s = pipes::send_packet_buffered(\ + body += fmt!{"let %s = pipes::send_packet_buffered(\ ptr::addr_of(b.buffer.data.%s));\n", - sp, *next.name); - body += #fmt("let %s = pipes::recv_packet_buffered(\ + sp, *next.name}; + body += fmt!{"let %s = pipes::recv_packet_buffered(\ ptr::addr_of(b.buffer.data.%s));\n", - rp, *next.name); + rp, *next.name}; } else { let pat = alt (this.dir, next.dir) { @@ -93,15 +93,15 @@ impl compile of gen_send for message { (recv, recv) { ~"(c, s)" } }; - body += #fmt("let %s = pipes::entangle();\n", pat); + body += fmt!{"let %s = pipes::entangle();\n", pat}; } - body += #fmt("let message = %s::%s(%s);\n", + body += fmt!{"let message = %s::%s(%s);\n", *this.proto.name, *self.name(), str::connect(vec::append_one(arg_names, @~"s") .map(|x| *x), - ~", ")); - body += #fmt("pipes::send(pipe, message);\n"); + ~", ")}; + body += fmt!{"pipes::send(pipe, message);\n"}; // return the new channel body += ~"c }"; @@ -117,7 +117,7 @@ impl compile of gen_send for message { } message(id, span, tys, this, none) { - #debug("pipec: no next state"); + debug!{"pipec: no next state"}; let arg_names = tys.mapi(|i, _ty| @(~"x_" + i.to_str())); let args_ast = (arg_names, tys).map( @@ -140,11 +140,11 @@ impl compile of gen_send for message { }; let mut body = ~"{ "; - body += #fmt("let message = %s::%s%s;\n", + body += fmt!{"let message = %s::%s%s;\n", *this.proto.name, *self.name(), - message_args); - body += #fmt("pipes::send(pipe, message);\n"); + message_args}; + body += fmt!{"pipes::send(pipe, message);\n"}; body += ~" }"; let body = cx.parse_expr(body); @@ -166,7 +166,7 @@ impl compile of gen_send for message { impl compile of to_type_decls for state { fn to_type_decls(cx: ext_ctxt) -> ~[@ast::item] { - #debug("pipec: to_type_decls"); + debug!{"pipec: to_type_decls"}; // This compiles into two different type declarations. Say the // state is called ping. This will generate both `ping` and // `ping_message`. The first contains data that the user cares @@ -206,7 +206,7 @@ impl compile of to_type_decls for state { } fn to_endpoint_decls(cx: ext_ctxt, dir: direction) -> ~[@ast::item] { - #debug("pipec: to_endpoint_decls"); + debug!{"pipec: to_endpoint_decls"}; let dir = alt dir { send { (*self).dir } recv { (*self).dir.reverse() } @@ -250,7 +250,7 @@ impl compile of gen_init for protocol { fn gen_init(cx: ext_ctxt) -> @ast::item { let ext_cx = cx; - #debug("gen_init"); + debug!{"gen_init"}; let start_state = self.states[0]; let body = if !self.is_bounded() { @@ -277,12 +277,12 @@ impl compile of gen_init for protocol { } }; - cx.parse_item(#fmt("fn init%s() -> (client::%s, server::%s)\ + cx.parse_item(fmt!{"fn init%s() -> (client::%s, server::%s)\ { import pipes::has_buffer; %s }", start_state.ty_params.to_source(), start_state.to_ty(cx).to_source(), start_state.to_ty(cx).to_source(), - body.to_source())) + body.to_source()}) } fn gen_buffer_init(ext_cx: ext_ctxt) -> @ast::expr { @@ -293,7 +293,7 @@ impl compile of gen_init for protocol { } fn gen_init_bounded(ext_cx: ext_ctxt) -> @ast::expr { - #debug("gen_init_bounded"); + debug!{"gen_init_bounded"}; let buffer_fields = self.gen_buffer_init(ext_cx); let buffer = #ast { @@ -305,9 +305,9 @@ impl compile of gen_init for protocol { ext_cx.block( self.states.map_to_vec( |s| ext_cx.parse_stmt( - #fmt("data.%s.set_buffer(buffer)", *s.name))), + fmt!{"data.%s.set_buffer(buffer)", *s.name})), ext_cx.parse_expr( - #fmt("ptr::addr_of(data.%s)", *self.states[0].name)))); + fmt!{"ptr::addr_of(data.%s)", *self.states[0].name}))); #ast {{ let buffer = $(buffer); @@ -442,7 +442,7 @@ impl parse_utils of ext_ctxt_parse_utils for ext_ctxt { alt res { some(ast) { ast } none { - #error("Parse error with ```\n%s\n```", s); + error!{"Parse error with ```\n%s\n```", s}; fail } } diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 1adff98f31c..b9f77ea3fc2 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -158,9 +158,9 @@ class protocol_ { let bounded = self.bounded.get(); bounded //if bounded && self.has_ty_params() { - // #debug("protocol %s has is bounded, but type parameters\ + // debug!{"protocol %s has is bounded, but type parameters\ // are not yet supported.", - // *self.name); + // *self.name}; // false //} //else { bounded } diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs index 4fd896e65bb..c027963cefa 100644 --- a/src/libsyntax/ext/qquote.rs +++ b/src/libsyntax/ext/qquote.rs @@ -185,7 +185,7 @@ fn finish<T: qq_helper> { let cm = ecx.codemap(); let str = @codemap::span_to_snippet(body.span, cm); - #debug["qquote--str==%?", str]; + debug!{"qquote--str==%?", str}; let fname = codemap::mk_substr_filename(cm, body.span); let node = parse_from_source_str (f, fname, codemap::fss_internal(body.span), str, @@ -211,7 +211,7 @@ fn finish<T: qq_helper> do str::chars_iter(*str) |ch| { if (j < g_len && i == cx.gather[j].lo) { assert ch == '$'; - let repl = #fmt("$%u ", j); + let repl = fmt!{"$%u ", j}; state = skip(str::char_len(repl)); str2 += repl; } diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs index 2f8e63facf9..b261e7657a2 100644 --- a/src/libsyntax/ext/simplext.rs +++ b/src/libsyntax/ext/simplext.rs @@ -289,9 +289,9 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], let len = vec::len(*ms); if old_len != len { let msg = - #fmt["'%s' occurs %u times, but ", *fv, len] + - #fmt["'%s' occurs %u times", *old_name, - old_len]; + fmt!{"'%s' occurs %u times, but ", *fv, len} + + fmt!{"'%s' occurs %u times", *old_name, + old_len}; cx.span_fatal(repeat_me.span, msg); } } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index ff7fedde34e..226292086f8 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -13,7 +13,7 @@ export expand_include; export expand_include_str; export expand_include_bin; -/* #line(): expands to the current line number */ +/* 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"); @@ -21,7 +21,7 @@ fn expand_line(cx: ext_ctxt, sp: span, arg: ast::mac_arg, ret mk_uint(cx, sp, loc.line); } -/* #col(): expands to the current column number */ +/* 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"); @@ -29,7 +29,7 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg, ret mk_uint(cx, sp, loc.col); } -/* #file(): expands to the current filename */ +/* file!{}: expands to the current filename */ /* The filemap (`loc.file`) contains a bunch more information we could spit * out if we wanted. */ fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, diff --git a/src/libsyntax/ext/tt/earley_parser.rs b/src/libsyntax/ext/tt/earley_parser.rs index 9b6383d5d3a..c7a2713c26e 100644 --- a/src/libsyntax/ext/tt/earley_parser.rs +++ b/src/libsyntax/ext/tt/earley_parser.rs @@ -274,13 +274,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 { match_nonterminal(bind,name,_) { - #fmt["%s ('%s')", *name, *bind] + fmt!{"%s ('%s')", *name, *bind} } _ { fail; } } }), ~" or "); - ret failure(sp, #fmt[ + ret failure(sp, fmt!{ "Local ambiguity: multiple parsing options: \ built-in NTs %s or %u other options.", - nts, next_eis.len()]); + nts, next_eis.len()}); } else if (bb_eis.len() == 0u && next_eis.len() == 0u) { ret failure(sp, ~"No rules expected the token " + to_str(*rdr.interner(), tok)); diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index e400a2b8eca..9ab6261052a 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -111,9 +111,9 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis { lis_contradiction(_) { rhs } lis_constraint(r_len, _) if l_len == r_len { lhs } lis_constraint(r_len, r_id) { - lis_contradiction(#fmt["Inconsistent lockstep iteration: \ + lis_contradiction(fmt!{"Inconsistent lockstep iteration: \ '%s' has %u items, but '%s' has %u", - *l_id, l_len, *r_id, r_len]) + *l_id, l_len, *r_id, r_len}) } } } @@ -233,8 +233,8 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { matched_seq(*) { r.sp_diag.span_fatal( copy r.cur_span, /* blame the macro writer */ - #fmt["variable '%s' is still repeating at this depth", - *ident]); + fmt!{"variable '%s' is still repeating at this depth", + *ident}); } } } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 737307bb648..c9224c2817f 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -119,7 +119,7 @@ fn consume_non_eol_whitespace(rdr: string_reader) { } fn push_blank_line_comment(rdr: string_reader, &comments: ~[cmnt]) { - #debug(">>> blank-line comment"); + debug!{">>> blank-line comment"}; let v: ~[~str] = ~[]; vec::push(comments, {style: blank_line, lines: v, pos: rdr.chpos}); } @@ -137,9 +137,9 @@ fn consume_whitespace_counting_blank_lines(rdr: string_reader, fn read_shebang_comment(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { - #debug(">>> shebang comment"); + debug!{">>> shebang comment"}; let p = rdr.chpos; - #debug("<<< shebang comment"); + debug!{"<<< shebang comment"}; vec::push(comments, { style: if code_to_the_left { trailing } else { isolated }, lines: ~[read_one_line_comment(rdr)], @@ -149,7 +149,7 @@ fn read_shebang_comment(rdr: string_reader, code_to_the_left: bool, fn read_line_comments(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { - #debug(">>> line comments"); + debug!{">>> line comments"}; let p = rdr.chpos; let mut lines: ~[~str] = ~[]; while rdr.curr == '/' && nextch(rdr) == '/' { @@ -161,7 +161,7 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool, vec::push(lines, line); consume_non_eol_whitespace(rdr); } - #debug("<<< line comments"); + debug!{"<<< line comments"}; if !lines.is_empty() { vec::push(comments, { style: if code_to_the_left { trailing } else { isolated }, @@ -192,7 +192,7 @@ fn trim_whitespace_prefix_and_push_line(&lines: ~[~str], fn read_block_comment(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { - #debug(">>> block comment"); + debug!{">>> block comment"}; let p = rdr.chpos; let mut lines: ~[~str] = ~[]; let mut col: uint = rdr.col; @@ -214,7 +214,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, let mut curr_line = ~"/*"; let mut level: int = 1; while level > 0 { - #debug("=== block comment level %d", level); + debug!{"=== block comment level %d", level}; 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); @@ -245,7 +245,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, if !is_eof(rdr) && rdr.curr != '\n' && vec::len(lines) == 1u { style = mixed; } - #debug("<<< block comment"); + debug!{"<<< block comment"}; vec::push(comments, {style: style, lines: lines, pos: p}); } @@ -257,7 +257,7 @@ fn peeking_at_comment(rdr: string_reader) -> bool { fn consume_comment(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { - #debug(">>> consume comment"); + debug!{">>> consume comment"}; if rdr.curr == '/' && nextch(rdr) == '/' { read_line_comments(rdr, code_to_the_left, comments); } else if rdr.curr == '/' && nextch(rdr) == '*' { @@ -265,7 +265,7 @@ fn consume_comment(rdr: string_reader, code_to_the_left: bool, } else if rdr.curr == '#' && nextch(rdr) == '!' { read_shebang_comment(rdr, code_to_the_left, comments); } else { fail; } - #debug("<<< consume comment"); + debug!{"<<< consume comment"}; } type lit = {lit: ~str, pos: uint}; diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 7898cd64890..314d0494bfb 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -113,7 +113,7 @@ impl parser_common of parser_common for parser { // A sanity check that the word we are asking for is a known keyword fn require_keyword(word: ~str) { if !self.keywords.contains_key(word) { - self.bug(#fmt("unknown keyword: %s", word)); + self.bug(fmt!{"unknown keyword: %s", word}); } } diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs index 125dc809079..8a53625be1e 100644 --- a/src/libsyntax/parse/eval.rs +++ b/src/libsyntax/parse/eval.rs @@ -20,9 +20,9 @@ fn eval_crate_directives(cx: ctx, fn eval_crate_directives_to_mod(cx: ctx, cdirs: ~[@ast::crate_directive], 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")); + debug!{"eval crate prefix: %s", prefix}; + debug!{"eval crate suffix: %s", + option::get_default(suffix, ~"none")}; let (cview_items, citems, cattrs) = parse_companion_mod(cx, prefix, suffix); let mut view_items: ~[@ast::view_item] = ~[]; @@ -63,9 +63,9 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>) } let modpath = companion_file(prefix, suffix); - #debug("looking for companion mod %s", modpath); + debug!{"looking for companion mod %s", modpath}; if file_exists(modpath) { - #debug("found companion mod"); + debug!{"found companion mod"}; let (p0, r0) = new_parser_etc_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE); let inner_attrs = p0.parse_inner_attrs_and_next(); diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 3c08fec743c..08ec1c5f242 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -417,8 +417,8 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { } let parsed = option::get(u64::from_str_radix(num_str, base as u64)); - #debug["lexing %s as an unsuffixed integer literal", - num_str]; + debug!{"lexing %s as an unsuffixed integer literal", + num_str}; ret token::LIT_INT_UNSUFFIXED(parsed as i64); } } @@ -429,7 +429,7 @@ fn scan_numeric_escape(rdr: string_reader, n_hex_digits: uint) -> char { let n = rdr.curr; bump(rdr); if !is_hex_digit(n) { - rdr.fatal(#fmt["illegal numeric character escape: %d", n as int]); + rdr.fatal(fmt!{"illegal numeric character escape: %d", n as int}); } accum_int *= 16; accum_int += hex_digit_val(n); @@ -572,7 +572,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { 'u' { c2 = scan_numeric_escape(rdr, 4u); } 'U' { c2 = scan_numeric_escape(rdr, 8u); } c2 { - rdr.fatal(#fmt["unknown character escape: %d", c2 as int]); + rdr.fatal(fmt!{"unknown character escape: %d", c2 as int}); } } } @@ -587,8 +587,8 @@ fn next_token_inner(rdr: string_reader) -> token::token { bump(rdr); while rdr.curr != '"' { if is_eof(rdr) { - rdr.fatal(#fmt["unterminated double quote string: %s", - get_str_from(rdr, n)]); + rdr.fatal(fmt!{"unterminated double quote string: %s", + get_str_from(rdr, n)}); } let ch = rdr.curr; @@ -614,7 +614,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { str::push_char(accum_str, scan_numeric_escape(rdr, 8u)); } c2 { - rdr.fatal(#fmt["unknown string escape: %d", c2 as int]); + rdr.fatal(fmt!{"unknown string escape: %d", c2 as int}); } } } @@ -649,7 +649,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { '/' { ret binop(rdr, token::SLASH); } '^' { ret binop(rdr, token::CARET); } '%' { ret binop(rdr, token::PERCENT); } - c { rdr.fatal(#fmt["unknown start of token: %d", c as int]); } + c { rdr.fatal(fmt!{"unknown start of token: %d", c as int}); } } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index ac130024546..1445dc30d10 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -273,13 +273,13 @@ class parser { let tps = p.parse_ty_params(); let d = p.parse_ty_fn_decl(pur); let hi = p.last_span.hi; - #debug["parse_trait_methods(): trait method signature ends in \ + debug!{"parse_trait_methods(): trait method signature ends in \ `%s`", - token_to_str(p.reader, p.token)]; + token_to_str(p.reader, p.token)}; alt p.token { token::SEMI { p.bump(); - #debug["parse_trait_methods(): parsing required method"]; + debug!{"parse_trait_methods(): parsing required method"}; // NB: at the moment, visibility annotations on required // methods are ignored; this could change. required({ident: ident, attrs: attrs, @@ -287,7 +287,7 @@ class parser { span: mk_sp(lo, hi)}) } token::LBRACE { - #debug["parse_trait_methods(): parsing provided method"]; + debug!{"parse_trait_methods(): parsing provided method"}; let (inner_attrs, body) = p.parse_inner_attrs_and_block(true); let attrs = vec::append(attrs, inner_attrs); @@ -632,7 +632,7 @@ class parser { } fn parse_path_with_tps(colons: bool) -> @path { - #debug["parse_path_with_tps(colons=%b)", colons]; + debug!{"parse_path_with_tps(colons=%b)", colons}; let lo = self.span.lo; let path = self.parse_path_without_tps(); @@ -1479,9 +1479,9 @@ class parser { // There may be other types of expressions that can // represent the callee in `for` and `do` expressions // but they aren't represented by tests - #debug("sugary call on %?", e.node); + debug!{"sugary call on %?", e.node}; self.span_fatal( - lo, #fmt("`%s` must be followed by a block call", keyword)); + lo, fmt!{"`%s` must be followed by a block call", keyword}); } } } @@ -2321,7 +2321,7 @@ class parser { attrs = vec::append(attrs_remaining, attrs); first = false; } - #debug["parse_mod_items: parse_item(attrs=%?)", attrs]; + debug!{"parse_mod_items: parse_item(attrs=%?)", attrs}; let vis = self.parse_visibility(private); alt self.parse_item(attrs, vis) { some(i) { vec::push(items, i); } @@ -2330,7 +2330,7 @@ class parser { token_to_str(self.reader, self.token) + ~"`"); } } - #debug["parse_mod_items: attrs=%?", attrs]; + debug!{"parse_mod_items: attrs=%?", attrs}; } if first && attrs_remaining.len() > 0u { @@ -2603,7 +2603,7 @@ class parser { let lo = self.span.lo; let first_ident = self.parse_ident(); let mut path = ~[first_ident]; - #debug("parsed view_path: %s", *first_ident); + debug!{"parsed view_path: %s", *first_ident}; alt self.token { token::EQ { // x = foo::bar diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 79679279f07..d01a111364a 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -63,7 +63,7 @@ enum token { STRING(@~str, int), BREAK(break_t), BEGIN(begin_t), END, EOF, } fn tok_str(++t: token) -> ~str { alt t { - STRING(s, len) { ret #fmt["STR(%s,%d)", *s, len]; } + STRING(s, len) { ret fmt!{"STR(%s,%d)", *s, len}; } BREAK(_) { ret ~"BREAK"; } BEGIN(_) { ret ~"BEGIN"; } END { ret ~"END"; } @@ -81,7 +81,7 @@ fn buf_str(toks: ~[mut token], szs: ~[mut int], left: uint, right: uint, while i != right && L != 0u { L -= 1u; if i != left { s += ~", "; } - s += #fmt["%d=%s", szs[i], tok_str(toks[i])]; + s += fmt!{"%d=%s", szs[i], tok_str(toks[i])}; i += 1u; i %= n; } @@ -99,7 +99,7 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer { // Yes 3, it makes the ring buffers big enough to never // fall behind. let n: uint = 3u * linewidth; - #debug("mk_printer %u", linewidth); + debug!{"mk_printer %u", linewidth}; let token: ~[mut token] = vec::to_mut(vec::from_elem(n, EOF)); let size: ~[mut int] = vec::to_mut(vec::from_elem(n, 0)); let scan_stack: ~[mut uint] = vec::to_mut(vec::from_elem(n, 0u)); @@ -235,7 +235,7 @@ impl printer for printer { // be very careful with this! fn replace_last_token(t: token) { self.token[self.right] = t; } fn pretty_print(t: token) { - #debug("pp ~[%u,%u]", self.left, self.right); + debug!{"pp ~[%u,%u]", self.left, self.right}; alt t { EOF { if !self.scan_stack_empty { @@ -252,17 +252,17 @@ impl printer for printer { self.left = 0u; self.right = 0u; } else { self.advance_right(); } - #debug("pp BEGIN/buffer ~[%u,%u]", self.left, self.right); + debug!{"pp BEGIN/buffer ~[%u,%u]", self.left, self.right}; self.token[self.right] = t; self.size[self.right] = -self.right_total; self.scan_push(self.right); } END { if self.scan_stack_empty { - #debug("pp END/print ~[%u,%u]", self.left, self.right); + debug!{"pp END/print ~[%u,%u]", self.left, self.right}; self.print(t, 0); } else { - #debug("pp END/buffer ~[%u,%u]", self.left, self.right); + debug!{"pp END/buffer ~[%u,%u]", self.left, self.right}; self.advance_right(); self.token[self.right] = t; self.size[self.right] = -1; @@ -276,7 +276,7 @@ impl printer for printer { self.left = 0u; self.right = 0u; } else { self.advance_right(); } - #debug("pp BREAK/buffer ~[%u,%u]", self.left, self.right); + debug!{"pp BREAK/buffer ~[%u,%u]", self.left, self.right}; self.check_stack(0); self.scan_push(self.right); self.token[self.right] = t; @@ -285,10 +285,10 @@ impl printer for printer { } STRING(s, len) { if self.scan_stack_empty { - #debug("pp STRING/print ~[%u,%u]", self.left, self.right); + debug!{"pp STRING/print ~[%u,%u]", self.left, self.right}; self.print(t, len); } else { - #debug("pp STRING/buffer ~[%u,%u]", self.left, self.right); + debug!{"pp STRING/buffer ~[%u,%u]", self.left, self.right}; self.advance_right(); self.token[self.right] = t; self.size[self.right] = len; @@ -299,14 +299,14 @@ impl printer for printer { } } fn check_stream() { - #debug("check_stream ~[%u, %u] with left_total=%d, right_total=%d", - self.left, self.right, self.left_total, self.right_total); + debug!{"check_stream ~[%u, %u] with left_total=%d, right_total=%d", + self.left, self.right, self.left_total, self.right_total}; if self.right_total - self.left_total > self.space { - #debug("scan window is %d, longer than space on line (%d)", - self.right_total - self.left_total, self.space); + debug!{"scan window is %d, longer than space on line (%d)", + self.right_total - self.left_total, self.space}; if !self.scan_stack_empty { if self.left == self.scan_stack[self.bottom] { - #debug("setting %u to infinity and popping", self.left); + debug!{"setting %u to infinity and popping", self.left}; self.size[self.scan_pop_bottom()] = size_infinity; } } @@ -315,7 +315,7 @@ impl printer for printer { } } fn scan_push(x: uint) { - #debug("scan_push %u", x); + debug!{"scan_push %u", x}; if self.scan_stack_empty { self.scan_stack_empty = false; } else { @@ -351,8 +351,8 @@ impl printer for printer { assert (self.right != self.left); } fn advance_left(++x: token, L: int) { - #debug("advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right, - self.left, L); + debug!{"advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right, + self.left, L}; if L >= 0 { self.print(x, L); alt x { @@ -392,13 +392,13 @@ impl printer for printer { } } fn print_newline(amount: int) { - #debug("NEWLINE %d", amount); + debug!{"NEWLINE %d", amount}; self.out.write_str(~"\n"); self.pending_indentation = 0; self.indent(amount); } fn indent(amount: int) { - #debug("INDENT %d", amount); + debug!{"INDENT %d", amount}; self.pending_indentation += amount; } fn get_top() -> print_stack_elt { @@ -417,24 +417,24 @@ impl printer for printer { self.out.write_str(s); } fn print(x: token, L: int) { - #debug("print %s %d (remaining line space=%d)", tok_str(x), L, - self.space); + debug!{"print %s %d (remaining line space=%d)", tok_str(x), L, + self.space}; log(debug, buf_str(self.token, self.size, self.left, self.right, 6u)); alt x { BEGIN(b) { if L > self.space { let col = self.margin - self.space + b.offset; - #debug("print BEGIN -> push broken block at col %d", col); + debug!{"print BEGIN -> push broken block at col %d", col}; self.print_stack.push({offset: col, pbreak: broken(b.breaks)}); } else { - #debug("print BEGIN -> push fitting block"); + debug!{"print BEGIN -> push fitting block"}; self.print_stack.push({offset: 0, pbreak: fits}); } } END { - #debug("print END -> pop END"); + debug!{"print END -> pop END"}; assert (self.print_stack.len() != 0u); self.print_stack.pop(); } @@ -442,22 +442,22 @@ impl printer for printer { let top = self.get_top(); alt top.pbreak { fits { - #debug("print BREAK in fitting block"); + debug!{"print BREAK in fitting block"}; self.space -= b.blank_space; self.indent(b.blank_space); } broken(consistent) { - #debug("print BREAK in consistent block"); + debug!{"print BREAK in consistent block"}; self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); } broken(inconsistent) { if L > self.space { - #debug("print BREAK w/ newline in inconsistent"); + debug!{"print BREAK w/ newline in inconsistent"}; self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); } else { - #debug("print BREAK w/o newline in inconsistent"); + debug!{"print BREAK w/o newline in inconsistent"}; self.indent(b.blank_space); self.space -= b.blank_space; } @@ -465,7 +465,7 @@ impl printer for printer { } } STRING(s, len) { - #debug("print STRING"); + debug!{"print STRING"}; assert (L == len); // assert L <= space; self.space -= len; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 32ff77e55a1..3c1252d3ddc 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -872,14 +872,14 @@ fn print_mac(s: ps, m: ast::mac) { bclose(s, m.span); } ast::mac_ellipsis { word(s.s, ~"..."); } - ast::mac_var(v) { word(s.s, #fmt("$%u", v)); } + ast::mac_var(v) { word(s.s, fmt!{"$%u", v}); } _ { /* fixme */ } } } fn print_vstore(s: ps, t: ast::vstore) { alt t { - ast::vstore_fixed(some(i)) { word(s.s, #fmt("%u", i)); } + 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, ~"@"); } diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs index 022b2183ec7..fede7d55af9 100644 --- a/src/rustc/back/link.rs +++ b/src/rustc/back/link.rs @@ -343,7 +343,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, metas: provided_metas, dep_hashes: ~[@~str]) -> ~str { fn len_and_str(s: ~str) -> ~str { - ret #fmt["%u_%s", str::len(s), s]; + ret fmt!{"%u_%s", str::len(s), s}; } fn len_and_str_lit(l: ast::lit) -> ~str { @@ -379,8 +379,8 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~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]); + sess.warn(fmt!{"missing crate link meta `%s`, using `%s` as default", + name, default}); } fn crate_meta_name(sess: session, _crate: ast::crate, @@ -393,8 +393,8 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str, let mut os = str::split_char(path::basename(output), '.'); if (vec::len(os) < 2u) { - sess.fatal(#fmt("output file name `%s` doesn't\ - appear to have an extension", output)); + sess.fatal(fmt!{"output file name `%s` doesn't\ + appear to have an extension", output}); } vec::pop(os); str::connect(os, ~".") @@ -505,7 +505,7 @@ fn mangle(ss: path) -> ~str { for ss.each |s| { alt s { path_name(s) | path_mod(s) { let sani = sanitize(*s); - n += #fmt["%u%s", str::len(sani), sani]; + n += fmt!{"%u%s", str::len(sani), sani}; } } } n += ~"E"; // End name-sequence. @@ -576,12 +576,12 @@ fn link_binary(sess: session, let output = if sess.building_library { let long_libname = - os::dll_filename(#fmt("%s-%s-%s", - *lm.name, lm.extras_hash, *lm.vers)); - #debug("link_meta.name: %s", *lm.name); - #debug("long_libname: %s", long_libname); - #debug("out_filename: %s", out_filename); - #debug("dirname(out_filename): %s", path::dirname(out_filename)); + os::dll_filename(fmt!{"%s-%s-%s", + *lm.name, lm.extras_hash, *lm.vers}); + debug!{"link_meta.name: %s", *lm.name}; + debug!{"long_libname: %s", long_libname}; + debug!{"out_filename: %s", out_filename}; + debug!{"dirname(out_filename): %s", path::dirname(out_filename)}; path::connect(path::dirname(out_filename), long_libname) } else { out_filename }; @@ -698,14 +698,14 @@ fn link_binary(sess: session, // 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, ~" ")]); + 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, ~" ")}); sess.note(prog.err + prog.out); sess.abort_if_errors(); } @@ -718,8 +718,8 @@ fn link_binary(sess: session, // Remove the temporary object file if we aren't saving temps if !sess.opts.save_temps { if ! os::remove_file(obj_filename) { - sess.warn(#fmt["failed to delete object file `%s`", - obj_filename]); + sess.warn(fmt!{"failed to delete object file `%s`", + obj_filename}); } } } diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs index bc49898bc1f..4f85fb48f2a 100644 --- a/src/rustc/back/rpath.rs +++ b/src/rustc/back/rpath.rs @@ -21,7 +21,7 @@ fn get_rpath_flags(sess: session::session, out_filename: ~str) -> ~[~str] { ret ~[]; } - #debug("preparing the RPATH!"); + debug!{"preparing the RPATH!"}; let cwd = os::getcwd(); let sysroot = sess.filesearch.sysroot(); @@ -45,20 +45,20 @@ fn get_sysroot_absolute_rt_lib(sess: session::session) -> path::path { } fn rpaths_to_flags(rpaths: ~[~str]) -> ~[~str] { - vec::map(rpaths, |rpath| #fmt("-Wl,-rpath,%s",rpath) ) + 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] { - #debug("cwd: %s", cwd); - #debug("sysroot: %s", sysroot); - #debug("output: %s", output); - #debug("libs:"); + debug!{"cwd: %s", cwd}; + debug!{"sysroot: %s", sysroot}; + debug!{"output: %s", output}; + debug!{"libs:"}; for libs.each |libpath| { - #debug(" %s", libpath); + debug!{" %s", libpath}; } - #debug("target_triple: %s", target_triple); + debug!{"target_triple: %s", target_triple}; // Use relative paths to the libraries. Binaries can be moved // as long as they maintain the relative relationship to the @@ -73,9 +73,9 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path, let fallback_rpaths = ~[get_install_prefix_rpath(cwd, target_triple)]; fn log_rpaths(desc: ~str, rpaths: ~[~str]) { - #debug("%s rpaths:", desc); + debug!{"%s rpaths:", desc}; for rpaths.each |rpath| { - #debug(" %s", rpath); + debug!{" %s", rpath}; } } @@ -124,8 +124,8 @@ fn get_rpath_relative_to_output(os: session::os, fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { assert path::path_is_absolute(abs1); assert path::path_is_absolute(abs2); - #debug("finding relative path from %s to %s", - abs1, abs2); + debug!{"finding relative path from %s to %s", + abs1, abs2}; let normal1 = path::normalize(abs1); let normal2 = path::normalize(abs2); let split1 = path::split(normal1); @@ -171,7 +171,7 @@ fn get_absolute(cwd: path::path, lib: path::path) -> path::path { } fn get_install_prefix_rpath(cwd: path::path, target_triple: ~str) -> ~str { - let install_prefix = #env("CFG_PREFIX"); + let install_prefix = env!{"CFG_PREFIX"}; if install_prefix == ~"" { fail ~"rustc compiled without CFG_PREFIX environment variable"; @@ -222,7 +222,7 @@ mod test { #[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 d = path::connect(env!{"CFG_PREFIX"}, ~"/lib/rustc/triple/lib"); assert str::ends_with(res, d); } diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs index e88c92d2110..7be6103e34f 100644 --- a/src/rustc/driver/driver.rs +++ b/src/rustc/driver/driver.rs @@ -115,8 +115,8 @@ fn time<T>(do_it: bool, what: ~str, thunk: fn() -> T) -> T { let start = std::time::precise_time_s(); let rv = thunk(); let end = std::time::precise_time_s(); - io::stdout().write_str(#fmt("time: %3.3f s\t%s\n", - end - start, what)); + io::stdout().write_str(fmt!{"time: %3.3f s\t%s\n", + end - start, what}); ret rv; } @@ -397,7 +397,7 @@ fn host_triple() -> ~str { // FIXME (#2400): Instead of grabbing the host triple we really should // 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"); + let ht = env!{"CFG_HOST_TRIPLE"}; ret if ht != ~"" { ht } else { @@ -432,8 +432,8 @@ fn build_session_options(match: getopts::match, let lint_name = str::replace(lint_name, ~"-", ~"_"); alt lint_dict.find(lint_name) { none { - early_error(demitter, #fmt("unknown %s flag: %s", - level_name, lint_name)); + early_error(demitter, fmt!{"unknown %s flag: %s", + level_name, lint_name}); } some(lint) { vec::push(lint_opts, (lint.lint, level)); @@ -452,7 +452,7 @@ fn build_session_options(match: getopts::match, if name == debug_flag { this_bit = bit; break; } } if this_bit == 0u { - early_error(demitter, #fmt("unknown debug flag: %s", debug_flag)) + early_error(demitter, fmt!{"unknown debug flag: %s", debug_flag}) } debugging_opts |= this_bit; } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index b5039b89731..4e457bde044 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -27,14 +27,14 @@ import io::reader_util; fn version(argv0: ~str) { let mut vers = ~"unknown version"; - let env_vers = #env["CFG_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())); + io::println(fmt!{"%s %s", argv0, vers}); + io::println(fmt!{"host: %s", host_triple()}); } fn usage(argv0: ~str) { - io::println(#fmt("Usage: %s [options] <input>\n", argv0) + + io::println(fmt!{"Usage: %s [options] <input>\n", argv0} + ~" Options: @@ -91,14 +91,14 @@ fn describe_warnings() { fn padded(max: uint, s: ~str) -> ~str { str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s } - io::println(#fmt("\nAvailable lint checks:\n")); - io::println(#fmt(" %s %7.7s %s", - padded(max_key, ~"name"), ~"default", ~"meaning")); - io::println(#fmt(" %s %7.7s %s\n", - padded(max_key, ~"----"), ~"-------", ~"-------")); + io::println(fmt!{"\nAvailable lint checks:\n"}); + io::println(fmt!{" %s %7.7s %s", + padded(max_key, ~"name"), ~"default", ~"meaning"}); + io::println(fmt!{" %s %7.7s %s\n", + padded(max_key, ~"----"), ~"-------", ~"-------"}); for lint_dict.each |k, v| { let k = str::replace(k, ~"_", ~"-"); - io::println(#fmt(" %s %7.7s %s", + io::println(fmt!{" %s %7.7s %s", padded(max_key, k), alt v.default { lint::allow { ~"allow" } @@ -106,16 +106,16 @@ fn describe_warnings() { lint::deny { ~"deny" } lint::forbid { ~"forbid" } }, - v.desc)); + v.desc}); } io::println(~""); } fn describe_debug_flags() { - io::println(#fmt("\nAvailable debug options:\n")); + io::println(fmt!{"\nAvailable debug options:\n"}); for session::debugging_opts_map().each |pair| { let (name, desc, _) = pair; - io::println(#fmt(" -Z%-20s -- %s", name, desc)); + io::println(fmt!{" -Z%-20s -- %s", name, desc}); } } diff --git a/src/rustc/front/intrinsic_inject.rs b/src/rustc/front/intrinsic_inject.rs index ea841c0700c..920d4e2ee8c 100644 --- a/src/rustc/front/intrinsic_inject.rs +++ b/src/rustc/front/intrinsic_inject.rs @@ -7,7 +7,7 @@ export inject_intrinsic; fn inject_intrinsic(sess: session, crate: @ast::crate) -> @ast::crate { - let intrinsic_module = @#include_str("intrinsic.rs"); + let intrinsic_module = @include_str!{"intrinsic.rs"}; let item = parse::parse_item_from_source_str(~"<intrinsic>", intrinsic_module, diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index 2e9b380314a..1cf825a5e6b 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -99,7 +99,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> option<@ast::item> { vec::push(cx.path, i.ident); - #debug("current path: %s", ast_util::path_name_i(cx.path)); + debug!{"current path: %s", ast_util::path_name_i(cx.path)}; if is_test_fn(i) { alt i.node { @@ -109,12 +109,12 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> ~"unsafe functions cannot be used for tests"); } _ { - #debug("this is a test function"); + debug!{"this is a test function"}; let test = {span: i.span, path: cx.path, ignore: is_ignored(cx, i), should_fail: should_fail(i)}; cx.testfns.push(test); - #debug("have %u test functions", cx.testfns.len()); + debug!{"have %u test functions", cx.testfns.len()}; } } } @@ -201,7 +201,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item { vis: ast::public, span: dummy_sp()}; - #debug("Synthetic test module:\n%s\n", pprust::item_to_str(@item)); + debug!{"Synthetic test module:\n%s\n", pprust::item_to_str(@item)}; ret @item; } @@ -276,7 +276,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty { } fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr { - #debug("building test vector from %u tests", cx.testfns.len()); + debug!{"building test vector from %u tests", cx.testfns.len()}; let mut descs = ~[]; for cx.testfns.each |test| { vec::push(descs, mk_test_desc_rec(cx, test)); @@ -296,7 +296,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let span = test.span; let path = test.path; - #debug("encoding %s", ast_util::path_name_i(path)); + debug!{"encoding %s", ast_util::path_name_i(path)}; let name_lit: ast::lit = nospan(ast::lit_str(@ast_util::path_name_i(path))); diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs index 7dbefa8e498..68fcb8c9183 100644 --- a/src/rustc/lib/llvm.rs +++ b/src/rustc/lib/llvm.rs @@ -1090,7 +1090,7 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> if addrspace == 0u { ~"" } else { - #fmt("addrspace(%u)", addrspace) + fmt!{"addrspace(%u)", addrspace} } }; ret addrstr + ~"*" + diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs index 28022a37320..03e5fde96a0 100644 --- a/src/rustc/metadata/creader.rs +++ b/src/rustc/metadata/creader.rs @@ -43,16 +43,16 @@ type cache_entry = { }; fn dump_crates(crate_cache: dvec<cache_entry>) { - #debug("resolved crates:"); + debug!{"resolved crates:"}; for crate_cache.each |entry| { - #debug("cnum: %?", entry.cnum); - #debug("span: %?", entry.span); - #debug("hash: %?", entry.hash); + debug!{"cnum: %?", entry.cnum}; + debug!{"span: %?", entry.span}; + debug!{"hash: %?", entry.hash}; let attrs = ~[ attr::mk_attr(attr::mk_list_item(@~"link", *entry.metas)) ]; for attr::find_linkage_attrs(attrs).each |attr| { - #debug("meta: %s", pprust::attr_to_str(attr)); + debug!{"meta: %s", pprust::attr_to_str(attr)}; } } } @@ -77,7 +77,7 @@ fn warn_if_multiple_versions(diag: span_handler, if matches.len() != 1u { diag.handler().warn( - #fmt("using multiple versions of crate `%s`", *name)); + fmt!{"using multiple versions of crate `%s`", *name}); for matches.each |match| { diag.span_note(match.span, ~"used here"); let attrs = ~[ @@ -102,7 +102,7 @@ type env = @{diag: span_handler, 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); + debug!{"resolving use stmt. ident: %?, meta: %?", ident, meta_items}; let cnum = resolve_crate(e, ident, meta_items, ~"", i.span); cstore::add_use_stmt_cnum(e.cstore, id, cnum); } @@ -238,7 +238,7 @@ fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item], // Go through the crate metadata and load any crates that it references fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map { - #debug("resolving deps of external crate"); + debug!{"resolving deps of external crate"}; // The map from crate numbers in the crate we're resolving to local crate // numbers let cnum_map = int_hash::<ast::crate_num>(); @@ -246,16 +246,16 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map { let extrn_cnum = dep.cnum; let cname = dep.name; let cmetas = metas_with(dep.vers, @~"vers", ~[]); - #debug("resolving dep crate %s ver: %s hash: %s", - *dep.name, *dep.vers, *dep.hash); + 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) { some(local_cnum) { - #debug("already have it"); + debug!{"already have it"}; // We've already seen this crate cnum_map.insert(extrn_cnum, local_cnum); } none { - #debug("need to load it"); + debug!{"need to load it"}; // This is a new one so we've got to load it // FIXME (#2404): Need better error reporting than just a bogus // span. diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs index 0ba76c49246..91a22b9fe2f 100644 --- a/src/rustc/metadata/csearch.rs +++ b/src/rustc/metadata/csearch.rs @@ -46,7 +46,7 @@ fn get_type_param_count(cstore: cstore::cstore, def: ast::def_id) -> uint { fn lookup_defs(cstore: cstore::cstore, cnum: ast::crate_num, path: ~[ast::ident]) -> ~[ast::def] { let mut result = ~[]; - #debug("lookup_defs: path = %? cnum = %?", path, cnum); + debug!{"lookup_defs: path = %? cnum = %?", path, cnum}; for resolve_path(cstore, cnum, path).each |elt| { let (c, data, def) = elt; vec::push(result, decoder::lookup_def(c, data, def)); @@ -68,8 +68,8 @@ fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num, path: ~[ast::ident]) -> ~[(ast::crate_num, @~[u8], ast::def_id)] { let cm = cstore::get_crate_data(cstore, cnum); - #debug("resolve_path %s in crates[%d]:%s", - ast_util::path_name_i(path), cnum, cm.name); + debug!{"resolve_path %s in crates[%d]:%s", + ast_util::path_name_i(path), cnum, cm.name}; let mut result = ~[]; for decoder::resolve_path(path, cm.data).each |def| { if def.crate == ast::local_crate { @@ -181,17 +181,17 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id, let cstore = tcx.cstore; let cdata = cstore::get_crate_data(cstore, class_id.crate); let all_items = ebml::get_doc(ebml::doc(cdata.data), tag_items); - #debug("Looking up %?", class_id); + debug!{"Looking up %?", class_id}; let class_doc = expect(tcx.diag, decoder::maybe_find_item(class_id.node, all_items), - || #fmt("get_field_type: class ID %? not found", - class_id) ); - #debug("looking up %? : %?", def, class_doc); + || fmt!{"get_field_type: class ID %? not found", + class_id} ); + debug!{"looking up %? : %?", def, class_doc}; let the_field = expect(tcx.diag, decoder::maybe_find_item(def.node, class_doc), - || #fmt("get_field_type: in class %?, field ID %? not found", - class_id, def) ); - #debug("got field data %?", the_field); + || fmt!{"get_field_type: in class %?, field ID %? not found", + class_id, def} ); + debug!{"got field data %?", the_field}; let ty = decoder::item_type(def, the_field, tcx, cdata); ret {bounds: @~[], rp: false, ty: ty}; } diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs index af9b6d57e57..fd541c33d2d 100644 --- a/src/rustc/metadata/cstore.rs +++ b/src/rustc/metadata/cstore.rs @@ -160,16 +160,16 @@ fn get_dep_hashes(cstore: cstore) -> ~[@~str] { for p(cstore).use_crate_map.each_value |cnum| { let cdata = cstore::get_crate_data(cstore, cnum); let hash = decoder::get_crate_hash(cdata.data); - #debug("Add hash[%s]: %s", cdata.name, *hash); + debug!{"Add hash[%s]: %s", cdata.name, *hash}; vec::push(result, {name: @cdata.name, hash: hash}); }; fn lteq(a: crate_hash, b: crate_hash) -> bool { ret *a.name <= *b.name; } let sorted = std::sort::merge_sort(lteq, result); - #debug("sorted:"); + debug!{"sorted:"}; for sorted.each |x| { - #debug(" hash[%s]: %s", *x.name, *x.hash); + debug!{" hash[%s]: %s", *x.name, *x.hash}; } fn mapper(ch: crate_hash) -> @~str { ret ch.hash; } ret vec::map(sorted, mapper); diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index 6d08b21f7e6..ba5ff3a6a9d 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -100,7 +100,7 @@ fn find_item(item_id: int, items: ebml::doc) -> ebml::doc { fn lookup_item(item_id: int, data: @~[u8]) -> ebml::doc { let items = ebml::get_doc(ebml::doc(data), tag_items); alt maybe_find_item(item_id, items) { - none { fail(#fmt("lookup_item: id not found: %d", item_id)); } + none { fail(fmt!{"lookup_item: id not found: %d", item_id}); } some(d) { d } } } @@ -231,7 +231,7 @@ fn resolve_path(path: ~[ast::ident], data: @~[u8]) -> ~[ast::def_id] { let paths = ebml::get_doc(md, tag_paths); let eqer = |a| eq_item(a, s); let mut result: ~[ast::def_id] = ~[]; - #debug("resolve_path: looking up %s", s); + debug!{"resolve_path: looking up %s", s}; for lookup_hash(paths, eqer, hash_path(s)).each |doc| { let did_doc = ebml::get_doc(doc, tag_def_id); vec::push(result, ebml::with_doc_data(did_doc, |d| parse_def_id(d))); @@ -295,7 +295,7 @@ fn item_to_def_like(item: ebml::doc, did: ast::def_id, cnum: ast::crate_num) 'I' { dl_def(ast::def_ty(did)) } 'i' { dl_impl(did) } 'g' | 'j' { dl_field } - ch { fail #fmt("unexpected family code: '%c'", ch) } + ch { fail fmt!{"unexpected family code: '%c'", ch} } } } @@ -351,8 +351,8 @@ fn get_class_method(cdata: cmd, id: ast::node_id, let mut found = none; let cls_items = alt maybe_find_item(id, items) { some(it) { it } - none { fail (#fmt("get_class_method: class id not found \ - when looking up method %s", *name)) }}; + none { fail (fmt!{"get_class_method: class id not found \ + when looking up method %s", *name}) }}; for ebml::tagged_docs(cls_items, tag_item_trait_method) |mid| { let m_did = class_member_id(mid, cdata); if item_name(mid) == name { @@ -361,7 +361,7 @@ fn get_class_method(cdata: cmd, id: ast::node_id, } alt found { some(found) { found } - none { fail (#fmt("get_class_method: no method named %s", *name)) } + none { fail (fmt!{"get_class_method: no method named %s", *name}) } } } @@ -370,8 +370,8 @@ fn class_dtor(cdata: cmd, id: ast::node_id) -> option<ast::def_id> { let mut found = none; let cls_items = alt maybe_find_item(id, items) { some(it) { it } - none { fail (#fmt("class_dtor: class id not found \ - when looking up dtor for %d", id)); } + none { fail (fmt!{"class_dtor: class id not found \ + when looking up dtor for %d", id}); } }; for ebml::tagged_docs(cls_items, tag_item_dtor) |doc| { let doc1 = ebml::get_doc(doc, tag_def_id); @@ -431,7 +431,7 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) { let def_id = class_member_id(item_doc, cdata); // Construct the def for this item. - #debug("(each_path) yielding explicit item: %s", name); + debug!{"(each_path) yielding explicit item: %s", name}; let def_like = item_to_def_like(item_doc, def_id, cdata.cnum); // Hand the information off to the iteratee. @@ -468,8 +468,8 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) { // Get the item. alt maybe_find_item(def_id.node, items) { none { - #debug("(each_path) ignoring implicit item: %s", - *path); + debug!{"(each_path) ignoring implicit item: %s", + *path}; } some(item_doc) { // Construct the def for this item. @@ -477,8 +477,8 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) { cdata.cnum); // Hand the information off to the iteratee. - #debug("(each_path) yielding implicit item: %s", - *path); + debug!{"(each_path) yielding implicit item: %s", + *path}; let this_path_entry = path_entry(*path, def_like); if (!f(this_path_entry)) { broken = true; // XXX: This is awful. @@ -511,7 +511,7 @@ fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt, id: ast::node_id, decode_inlined_item: decode_inlined_item ) -> csearch::found_ast { - #debug("Looking up item: %d", id); + debug!{"Looking up item: %d", id}; let item_doc = lookup_item(id, cdata.data); let path = vec::init(item_path(item_doc)); alt decode_inlined_item(cdata, tcx, path, item_doc) { @@ -594,8 +594,8 @@ fn get_impls_for_mod(cdata: cmd, for ebml::tagged_docs(mod_item, tag_mod_impl) |doc| { let did = ebml::with_doc_data(doc, |d| parse_def_id(d)); let local_did = translate_def_id(cdata, did); - #debug("(get impls for mod) getting did %? for '%?'", - local_did, name); + debug!{"(get impls for mod) getting did %? for '%?'", + local_did, name}; // The impl may be defined in a different crate. Ask the caller // to give us the metadata let impl_cdata = get_cdata(local_did.crate); @@ -723,7 +723,7 @@ 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)); } + none { fail (fmt!{"describe_def: item not found %?", id}); } }; ret item_family_to_str(item_family(it)); } @@ -800,15 +800,15 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] { fn list_meta_items(meta_items: ebml::doc, out: io::writer) { for get_meta_items(meta_items).each |mi| { - out.write_str(#fmt["%s\n", pprust::meta_item_to_str(*mi)]); + out.write_str(fmt!{"%s\n", pprust::meta_item_to_str(*mi)}); } } fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::writer) { - out.write_str(#fmt("=Crate Attributes (%s)=\n", *hash)); + 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(fmt!{"%s\n", pprust::attribute_to_str(attr)}); } out.write_str(~"\n\n"); @@ -843,8 +843,8 @@ fn list_crate_deps(data: @~[u8], out: io::writer) { 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(fmt!{"%d %s-%s-%s\n", + dep.cnum, *dep.name, *dep.hash, *dep.vers}); } out.write_str(~"\n"); @@ -871,8 +871,8 @@ fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::writer) { do iter_crate_items(bytes) |tag, path, did| { // Don't print out any metadata info about intrinsics if tag != tag_paths_foreign_path { - out.write_str(#fmt["%s (%s)\n", path, - describe_def(items, did)]); + out.write_str(fmt!{"%s (%s)\n", path, + describe_def(items, did)}); } } out.write_str(~"\n"); diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 6f4716208a2..ee4a8bdd63f 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -273,7 +273,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]) { @@ -318,7 +318,7 @@ fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) { some(x) { x } none { ecx.diag.handler().bug( - #fmt("encode_symbol: id not found %d", id)); + fmt!{"encode_symbol: id not found %d", id}); } }; ebml_w.writer.write(str::bytes(sym)); @@ -400,17 +400,17 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod, encode_def_id(ebml_w, local_def(id)); encode_family(ebml_w, 'm'); encode_name(ebml_w, name); - #debug("(encoding info for module) encoding info for module ID %d", id); + debug!{"(encoding info for module) encoding info for module ID %d", id}; // the impl map contains ref_ids let impls = ecx.impl_map(id); for impls.each |i| { let (ident, did) = i; - #debug("(encoding info for module) ... encoding impl %s (%?/%?), \ + debug!{"(encoding info for module) ... encoding impl %s (%?/%?), \ exported? %?", *ident, did, ast_map::node_id_to_str(ecx.tcx.items, did.node), - ast_util::is_exported(ident, md)); + ast_util::is_exported(ident, md)}; ebml_w.start_tag(tag_mod_impl); alt ecx.tcx.items.find(did.node) { @@ -456,7 +456,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer, vec::push(*index, {val: id, pos: ebml_w.writer.tell()}); vec::push(*global_index, {val: id, pos: ebml_w.writer.tell()}); ebml_w.start_tag(tag_items_data_item); - #debug("encode_info_for_class: doing %s %d", *nm, id); + debug!{"encode_info_for_class: doing %s %d", *nm, id}; encode_visibility(ebml_w, vis); encode_name(ebml_w, nm); encode_path(ebml_w, path, ast_map::path_name(nm)); @@ -473,7 +473,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer, {val: m.id, pos: ebml_w.writer.tell()}); let impl_path = vec::append_one(path, ast_map::path_name(m.ident)); - #debug("encode_info_for_class: doing %s %d", *m.ident, m.id); + debug!{"encode_info_for_class: doing %s %d", *m.ident, m.id}; encode_info_for_method(ecx, ebml_w, impl_path, should_inline(m.attrs), id, m, vec::append(class_tps, m.tps)); @@ -496,8 +496,8 @@ fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer, encode_family(ebml_w, purity_fn_family(decl.purity)); encode_type_param_bounds(ebml_w, ecx, tps); let its_ty = node_id_to_type(ecx.tcx, id); - #debug("fn name = %s ty = %s its node id = %d", *ident, - util::ppaux::ty_to_str(ecx.tcx, its_ty), id); + debug!{"fn name = %s ty = %s its node id = %d", *ident, + util::ppaux::ty_to_str(ecx.tcx, its_ty), id}; encode_type(ecx, ebml_w, its_ty); encode_path(ebml_w, path, ast_map::path_name(ident)); alt item { @@ -515,7 +515,7 @@ fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer, impl_path: ast_map::path, should_inline: bool, parent_id: node_id, m: @method, all_tps: ~[ty_param]) { - #debug("encode_info_for_method: %d %s %u", m.id, *m.ident, all_tps.len()); + debug!{"encode_info_for_method: %d %s %u", m.id, *m.ident, all_tps.len()}; ebml_w.start_tag(tag_items_data_item); encode_def_id(ebml_w, local_def(m.id)); encode_family(ebml_w, purity_fn_family(m.decl.purity)); @@ -838,8 +838,8 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer, /* encode ctor, then encode items */ alt i.node { item_class(tps, _, _, some(ctor), m_dtor) { - #debug("encoding info for ctor %s %d", *i.ident, - ctor.node.id); + debug!{"encoding info for ctor %s %d", *i.ident, + ctor.node.id}; vec::push(*index, { val: ctor.node.id, pos: ebml_w.writer.tell() diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs index cb773589dcc..9e68ce12a3c 100644 --- a/src/rustc/metadata/filesearch.rs +++ b/src/rustc/metadata/filesearch.rs @@ -62,7 +62,7 @@ fn mk_filesearch(maybe_sysroot: option<path>, } let sysroot = get_sysroot(maybe_sysroot); - #debug("using sysroot = %s", sysroot); + debug!{"using sysroot = %s", sysroot}; {sysroot: sysroot, addl_lib_search_paths: addl_lib_search_paths, target_triple: target_triple} as filesearch @@ -71,16 +71,16 @@ fn mk_filesearch(maybe_sysroot: option<path>, fn search<T: copy>(filesearch: filesearch, pick: pick<T>) -> option<T> { let mut rslt = none; for filesearch.lib_search_paths().each |lib_search_path| { - #debug("searching %s", lib_search_path); + debug!{"searching %s", lib_search_path}; for os::list_dir_path(lib_search_path).each |path| { - #debug("testing %s", path); + debug!{"testing %s", path}; let maybe_picked = pick(path); if option::is_some(maybe_picked) { - #debug("picked %s", path); + debug!{"picked %s", path}; rslt = maybe_picked; break; } else { - #debug("rejected %s", path); + debug!{"rejected %s", path}; } } if option::is_some(rslt) { break; } @@ -172,7 +172,7 @@ 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 { - let libdir = #env("CFG_LIBDIR"); + let libdir = env!{"CFG_LIBDIR"}; if str::is_empty(libdir) { fail ~"rustc compiled without CFG_LIBDIR environment variable"; } diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs index 862e6b90e7d..76cfba66b73 100644 --- a/src/rustc/metadata/loader.rs +++ b/src/rustc/metadata/loader.rs @@ -41,7 +41,7 @@ fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} { some(t) { ret t; } none { cx.diag.span_fatal( - cx.span, #fmt["can't find crate for `%s`", *cx.ident]); + cx.span, fmt!{"can't find crate for `%s`", *cx.ident}); } } } @@ -71,27 +71,27 @@ fn find_library_crate_aux(cx: ctxt, let mut matches = ~[]; filesearch::search(filesearch, |path| { - #debug("inspecting file %s", path); + debug!{"inspecting file %s", 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); + debug!{"skipping %s, doesn't look like %s*%s", path, prefix, + suffix}; option::none::<()> } else { - #debug("%s is a candidate", path); + debug!{"%s is a candidate", path}; alt get_metadata_section(cx.os, path) { option::some(cvec) { if !crate_matches(cvec, cx.metas, cx.hash) { - #debug("skipping %s, metadata doesn't match", path); + debug!{"skipping %s, metadata doesn't match", path}; option::none::<()> } else { - #debug("found %s with matching metadata", path); + debug!{"found %s with matching metadata", path}; vec::push(matches, {ident: path, data: cvec}); option::none::<()> } } _ { - #debug("could not load metadata for %s", path); + debug!{"could not load metadata for %s", path}; option::none::<()> } } @@ -104,10 +104,10 @@ fn find_library_crate_aux(cx: ctxt, some(matches[0]) } else { cx.diag.span_err( - cx.span, #fmt("multiple matching crates for `%s`", *crate_name)); + cx.span, fmt!{"multiple matching crates for `%s`", *crate_name}); cx.diag.handler().note(~"candidates:"); for matches.each |match| { - cx.diag.handler().note(#fmt("path: %s", match.ident)); + cx.diag.handler().note(fmt!{"path: %s", match.ident}); let attrs = decoder::get_crate_attributes(match.data); note_linkage_attrs(cx.diag, attrs); } @@ -133,7 +133,7 @@ fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> @~str { fn note_linkage_attrs(diag: span_handler, attrs: ~[ast::attribute]) { for attr::find_linkage_attrs(attrs).each |attr| { - diag.handler().note(#fmt("meta: %s", pprust::attr_to_str(attr))); + diag.handler().note(fmt!{"meta: %s", pprust::attr_to_str(attr)}); } } @@ -151,18 +151,18 @@ fn crate_matches(crate_data: @~[u8], metas: ~[@ast::meta_item], fn metadata_matches(extern_metas: ~[@ast::meta_item], local_metas: ~[@ast::meta_item]) -> bool { - #debug("matching %u metadata requirements against %u items", - vec::len(local_metas), vec::len(extern_metas)); + debug!{"matching %u metadata requirements against %u items", + vec::len(local_metas), vec::len(extern_metas)}; - #debug("crate metadata:"); + debug!{"crate metadata:"}; for extern_metas.each |have| { - #debug(" %s", pprust::meta_item_to_str(*have)); + debug!{" %s", pprust::meta_item_to_str(*have)}; } for local_metas.each |needed| { - #debug("looking for %s", pprust::meta_item_to_str(*needed)); + debug!{"looking for %s", pprust::meta_item_to_str(*needed)}; if !attr::contains(extern_metas, needed) { - #debug("missing %s", pprust::meta_item_to_str(*needed)); + debug!{"missing %s", pprust::meta_item_to_str(*needed)}; ret false; } } diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs index 7ae96eb8032..fad9d2d942f 100644 --- a/src/rustc/metadata/tydecode.rs +++ b/src/rustc/metadata/tydecode.rs @@ -297,16 +297,16 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { } 'B' { ty::mk_opaque_box(st.tcx) } 'a' { - #debug("saw a class"); + debug!{"saw a class"}; assert (next(st) == '['); - #debug("saw a ["); + debug!{"saw a ["}; let did = parse_def(st, conv); - #debug("parsed a def_id %?", did); + debug!{"parsed a def_id %?", did}; let substs = parse_substs(st, conv); assert (next(st) == ']'); ret ty::mk_class(st.tcx, did, substs); } - c { #error("unexpected char in type string: %c", c); fail;} + c { error!{"unexpected char in type string: %c", c}; fail;} } } @@ -389,7 +389,7 @@ fn parse_def_id(buf: &[u8]) -> ast::def_id { let len = vec::len(buf); while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; } if colon_idx == len { - #error("didn't find ':' when parsing def id"); + error!{"didn't find ':' when parsing def id"}; fail; } let crate_part = vec::slice(buf, 0u, colon_idx); @@ -397,13 +397,13 @@ fn parse_def_id(buf: &[u8]) -> ast::def_id { let crate_num = alt uint::parse_buf(crate_part, 10u) { some(cn) { cn as int } - none { fail (#fmt("internal error: parse_def_id: crate number \ - expected, but found %?", crate_part)); } + none { fail (fmt!{"internal error: parse_def_id: crate number \ + expected, but found %?", crate_part}); } }; let def_num = alt uint::parse_buf(def_part, 10u) { some(dn) { dn as int } - none { fail (#fmt("internal error: parse_def_id: id expected, but \ - found %?", def_part)); } + none { fail (fmt!{"internal error: parse_def_id: id expected, but \ + found %?", def_part}); } }; ret {crate: crate_num, node: def_num}; } diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index 1471bbd1acb..7bcf6d77841 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -293,15 +293,15 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str(&"C~"); } ty::ty_opaque_box { w.write_char('B'); } ty::ty_class(def, substs) { - #debug("~~~~ %s", ~"a["); + debug!{"~~~~ %s", ~"a["}; w.write_str(&"a["); let s = cx.ds(def); - #debug("~~~~ %s", s); + 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(']'); } } diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs index 1428d9e8982..bbbf8947792 100644 --- a/src/rustc/middle/astencode.rs +++ b/src/rustc/middle/astencode.rs @@ -89,9 +89,9 @@ fn encode_inlined_item(ecx: @e::encode_ctxt, path: ast_map::path, ii: ast::inlined_item, maps: maps) { - #debug["> Encoding inlined item: %s::%s (%u)", + debug!{"> Encoding inlined item: %s::%s (%u)", ast_map::path_to_str(path), *ii.ident(), - ebml_w.writer.tell()]; + ebml_w.writer.tell()}; let id_range = ast_util::compute_id_range_for_inlined_item(ii); do ebml_w.wr_tag(c::tag_ast as uint) { @@ -100,9 +100,9 @@ fn encode_inlined_item(ecx: @e::encode_ctxt, encode_side_tables_for_ii(ecx, maps, ebml_w, ii); } - #debug["< Encoded inlined fn: %s::%s (%u)", + debug!{"< Encoded inlined fn: %s::%s (%u)", ast_map::path_to_str(path), *ii.ident(), - ebml_w.writer.tell()]; + ebml_w.writer.tell()}; } fn decode_inlined_item(cdata: cstore::crate_metadata, @@ -114,7 +114,7 @@ fn decode_inlined_item(cdata: cstore::crate_metadata, alt par_doc.opt_child(c::tag_ast) { none { none } some(ast_doc) { - #debug["> Decoding inlined fn: %s::?", ast_map::path_to_str(path)]; + debug!{"> Decoding inlined fn: %s::?", ast_map::path_to_str(path)}; let ast_dsr = ebml::ebml_deserializer(ast_doc); let from_id_range = ast_util::deserialize_id_range(ast_dsr); let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range); @@ -125,14 +125,14 @@ fn decode_inlined_item(cdata: cstore::crate_metadata, let ii = renumber_ast(xcx, raw_ii); ast_map::map_decoded_item(tcx.sess.diagnostic(), dcx.tcx.items, path, ii); - #debug["Fn named: %s", *ii.ident()]; + debug!{"Fn named: %s", *ii.ident()}; decode_side_tables(xcx, ast_doc); - #debug["< Decoded inlined fn: %s::%s", - ast_map::path_to_str(path), *ii.ident()]; + debug!{"< Decoded inlined fn: %s::%s", + ast_map::path_to_str(path), *ii.ident()}; alt ii { ast::ii_item(i) { - #debug(">>> DECODED ITEM >>>\n%s\n<<< DECODED ITEM <<<", - syntax::print::pprust::item_to_str(i)); + debug!{">>> DECODED ITEM >>>\n%s\n<<< DECODED ITEM <<<", + syntax::print::pprust::item_to_str(i)}; } _ { } } @@ -641,7 +641,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt, id: ast::node_id) { let tcx = ecx.tcx; - #debug["Encoding side tables for id %d", id]; + debug!{"Encoding side tables for id %d", id}; do option::iter(tcx.def_map.find(id)) |def| { do ebml_w.tag(c::tag_table_def) { @@ -833,9 +833,9 @@ fn decode_side_tables(xcx: extended_decode_ctxt, let id0 = entry_doc[c::tag_table_id as uint].as_int(); let id = xcx.tr_id(id0); - #debug[">> Side table document with tag 0x%x \ + debug!{">> Side table document with tag 0x%x \ found for id %d (orig %d)", - tag, id, id0]; + tag, id, id0}; if tag == (c::tag_table_mutbl as uint) { dcx.maps.mutbl_map.insert(id, ()); @@ -884,11 +884,11 @@ fn decode_side_tables(xcx: extended_decode_ctxt, dcx.tcx.borrowings.insert(id, borrow); } else { xcx.dcx.tcx.sess.bug( - #fmt["unknown tag found in side tables: %x", tag]); + fmt!{"unknown tag found in side tables: %x", tag}); } } - #debug[">< Side table doc loaded"]; + debug!{">< Side table doc loaded"}; } } @@ -931,21 +931,21 @@ fn mk_ctxt() -> fake_ext_ctxt { #[cfg(test)] fn roundtrip(in_item: @ast::item) { - #debug["in_item = %s", pprust::item_to_str(in_item)]; + debug!{"in_item = %s", pprust::item_to_str(in_item)}; let mbuf = io::mem_buffer(); let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf)); encode_item_ast(ebml_w, in_item); let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf)); let out_item = decode_item_ast(ebml_doc); - #debug["out_item = %s", pprust::item_to_str(out_item)]; + debug!{"out_item = %s", pprust::item_to_str(out_item)}; let exp_str = io::with_str_writer(|w| ast::serialize_item(w, *in_item) ); let out_str = io::with_str_writer(|w| ast::serialize_item(w, *out_item) ); - #debug["expected string: %s", exp_str]; - #debug["actual string : %s", out_str]; + debug!{"expected string: %s", exp_str}; + debug!{"actual string : %s", out_str}; assert exp_str == out_str; } @@ -953,7 +953,7 @@ fn roundtrip(in_item: @ast::item) { #[test] fn test_basic() { let ext_cx = mk_ctxt(); - roundtrip(#ast(item){ + roundtrip(#ast[item]{ fn foo() {} }); } @@ -961,7 +961,7 @@ fn test_basic() { #[test] fn test_smalltalk() { let ext_cx = mk_ctxt(); - roundtrip(#ast(item){ + roundtrip(#ast[item]{ fn foo() -> int { 3 + 4 } // first smalltalk program ever executed. }); } @@ -969,7 +969,7 @@ fn test_smalltalk() { #[test] fn test_more() { let ext_cx = mk_ctxt(); - roundtrip(#ast(item){ + roundtrip(#ast[item]{ fn foo(x: uint, y: uint) -> uint { let z = x + y; ret z; @@ -980,14 +980,14 @@ fn test_more() { #[test] fn test_simplification() { let ext_cx = mk_ctxt(); - let item_in = ast::ii_item(#ast(item) { + let item_in = ast::ii_item(#ast[item] { fn new_int_alist<B: copy>() -> alist<int, B> { fn eq_int(&&a: int, &&b: int) -> bool { a == b } ret {eq_fn: eq_int, mut data: ~[]}; } }); let item_out = simplify_ast(item_in); - let item_exp = ast::ii_item(#ast(item) { + let item_exp = ast::ii_item(#ast[item] { fn new_int_alist<B: copy>() -> alist<int, B> { ret {eq_fn: eq_int, mut data: ~[]}; } diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index df09a585f47..2c326aa68ef 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -255,16 +255,16 @@ fn check_crate(tcx: ty::ctxt, if tcx.sess.borrowck_stats() { io::println(~"--- borrowck stats ---"); - io::println(#fmt["paths requiring guarantees: %u", - bccx.guaranteed_paths]); - io::println(#fmt["paths requiring loans : %s", - make_stat(bccx, bccx.loaned_paths_same)]); - io::println(#fmt["paths requiring imm loans : %s", - make_stat(bccx, bccx.loaned_paths_imm)]); - io::println(#fmt["stable paths : %s", - make_stat(bccx, bccx.stable_paths)]); - io::println(#fmt["paths requiring purity : %s", - make_stat(bccx, bccx.req_pure_paths)]); + io::println(fmt!{"paths requiring guarantees: %u", + bccx.guaranteed_paths}); + io::println(fmt!{"paths requiring loans : %s", + make_stat(bccx, bccx.loaned_paths_same)}); + io::println(fmt!{"paths requiring imm loans : %s", + make_stat(bccx, bccx.loaned_paths_imm)}); + io::println(fmt!{"stable paths : %s", + make_stat(bccx, bccx.stable_paths)}); + io::println(fmt!{"paths requiring purity : %s", + make_stat(bccx, bccx.req_pure_paths)}); } ret (bccx.root_map, bccx.mutbl_map); @@ -272,7 +272,7 @@ fn check_crate(tcx: ty::ctxt, 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] + fmt!{"%u (%.0f%%)", stat , stat_f * 100f / total} } } @@ -465,8 +465,8 @@ impl error_methods for borrowck_ctxt { fn report(err: bckerr) { self.span_err( err.cmt.span, - #fmt["illegal borrow: %s", - self.bckerr_code_to_str(err.code)]); + fmt!{"illegal borrow: %s", + self.bckerr_code_to_str(err.code)}); } fn span_err(s: span, m: ~str) { @@ -499,15 +499,15 @@ impl to_str_methods for borrowck_ctxt { 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] } + 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} } cat_deref(cmt, derefs, ptr) { - #fmt["%s->(%s, %u)", self.cat_to_repr(cmt.cat), - self.ptr_sigil(ptr), derefs] + fmt!{"%s->(%s, %u)", self.cat_to_repr(cmt.cat), + self.ptr_sigil(ptr), derefs} } cat_comp(cmt, comp) { - #fmt["%s.%s", self.cat_to_repr(cmt.cat), self.comp_to_repr(comp)] + fmt!{"%s.%s", self.cat_to_repr(cmt.cat), self.comp_to_repr(comp)} } cat_discr(cmt, _) { self.cat_to_repr(cmt.cat) } } @@ -542,29 +542,29 @@ impl to_str_methods for borrowck_ctxt { fn lp_to_str(lp: @loan_path) -> ~str { alt *lp { lp_local(node_id) { - #fmt["local(%d)", node_id] + fmt!{"local(%d)", node_id} } lp_arg(node_id) { - #fmt["arg(%d)", node_id] + fmt!{"arg(%d)", node_id} } lp_deref(lp, ptr) { - #fmt["%s->(%s)", self.lp_to_str(lp), - self.ptr_sigil(ptr)] + fmt!{"%s->(%s)", self.lp_to_str(lp), + self.ptr_sigil(ptr)} } lp_comp(lp, comp) { - #fmt["%s.%s", self.lp_to_str(lp), - self.comp_to_repr(comp)] + fmt!{"%s.%s", self.lp_to_str(lp), + self.comp_to_repr(comp)} } } } fn cmt_to_repr(cmt: cmt) -> ~str { - #fmt["{%s id:%d m:%s lp:%s ty:%s}", + 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) ), - ty_to_str(self.tcx, cmt.ty)] + ty_to_str(self.tcx, cmt.ty)} } fn cmt_to_str(cmt: cmt) -> ~str { @@ -580,8 +580,8 @@ impl to_str_methods for borrowck_ctxt { 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.ptr_sigil(pk)] } + cat_deref(_, _, pk) { fmt!{"dereference of %s %s pointer", + mut_str, self.ptr_sigil(pk)} } cat_stack_upvar(_) { ~"captured outer " + mut_str + ~" variable in a stack closure" } @@ -610,8 +610,8 @@ impl to_str_methods for borrowck_ctxt { 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)] + 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" @@ -626,16 +626,16 @@ impl to_str_methods for borrowck_ctxt { ~"rooting is not permitted" } err_out_of_root_scope(super_scope, sub_scope) { - #fmt["managed value would have to be rooted for lifetime %s, \ + fmt!{"managed value would have to be rooted for lifetime %s, \ but can only be rooted for lifetime %s", self.region_to_str(sub_scope), - self.region_to_str(super_scope)] + self.region_to_str(super_scope)} } err_out_of_scope(super_scope, sub_scope) { - #fmt["borrowed pointer has lifetime %s, \ + fmt!{"borrowed pointer has lifetime %s, \ but the borrowed value only has lifetime %s", self.region_to_str(sub_scope), - self.region_to_str(super_scope)] + self.region_to_str(super_scope)} } } } diff --git a/src/rustc/middle/borrowck/categorization.rs b/src/rustc/middle/borrowck/categorization.rs index d8c88d415ac..6f5b5d139d3 100644 --- a/src/rustc/middle/borrowck/categorization.rs +++ b/src/rustc/middle/borrowck/categorization.rs @@ -89,8 +89,8 @@ fn deref_kind(tcx: ty::ctxt, t: ty::t) -> deref_kind { some(k) {k} none { tcx.sess.bug( - #fmt["deref_cat() invoked on non-derefable type %s", - ty_to_str(tcx, t)]); + fmt!{"deref_cat() invoked on non-derefable type %s", + ty_to_str(tcx, t)}); } } } @@ -118,15 +118,15 @@ impl public_methods for borrowck_ctxt { _ { self.tcx.sess.span_bug( expr.span, - #fmt["Borrowing of non-derefable type `%s`", - ty_to_str(self.tcx, expr_ty)]); + fmt!{"Borrowing of non-derefable type `%s`", + ty_to_str(self.tcx, expr_ty)}); } } } fn cat_expr(expr: @ast::expr) -> cmt { - #debug["cat_expr: id=%d expr=%s", - expr.id, pprust::expr_to_str(expr)]; + debug!{"cat_expr: id=%d expr=%s", + expr.id, pprust::expr_to_str(expr)}; let tcx = self.tcx; let expr_ty = tcx.ty(expr); @@ -142,8 +142,8 @@ impl public_methods for borrowck_ctxt { none { tcx.sess.span_bug( e_base.span, - #fmt["Explicit deref of non-derefable type `%s`", - ty_to_str(tcx, tcx.ty(e_base))]); + fmt!{"Explicit deref of non-derefable type `%s`", + ty_to_str(tcx, tcx.ty(e_base))}); } } } @@ -318,8 +318,8 @@ impl public_methods for borrowck_ctxt { none { self.tcx.sess.span_bug( node.span(), - #fmt["Cannot find field `%s` in type `%s`", - *f_name, ty_to_str(self.tcx, base_cmt.ty)]); + fmt!{"Cannot find field `%s` in type `%s`", + *f_name, ty_to_str(self.tcx, base_cmt.ty)}); } }; let m = self.inherited_mutability(base_cmt.mutbl, f_mutbl); @@ -382,8 +382,8 @@ impl public_methods for borrowck_ctxt { none { self.tcx.sess.span_bug( expr.span, - #fmt["Explicit index of non-index type `%s`", - ty_to_str(self.tcx, base_cmt.ty)]); + fmt!{"Explicit index of non-index type `%s`", + ty_to_str(self.tcx, base_cmt.ty)}); } }; diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index d32d5dfd4a9..4306d457378 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -157,12 +157,12 @@ impl methods for check_loan_ctxt { callee_span: span) { let tcx = self.tcx(); - #debug["check_pure_callee_or_arg(pc=%?, expr=%?, \ + debug!{"check_pure_callee_or_arg(pc=%?, expr=%?, \ callee_id=%d, ty=%s)", pc, opt_expr.map(|e| pprust::expr_to_str(e) ), callee_id, - ty_to_str(self.tcx(), ty::node_id_to_type(tcx, callee_id))]; + ty_to_str(self.tcx(), ty::node_id_to_type(tcx, callee_id))}; // Purity rules: an expr B is a legal callee or argument to a // call within a pure function A if at least one of the @@ -202,8 +202,8 @@ impl methods for check_loan_ctxt { ast::impure_fn | ast::unsafe_fn | ast::extern_fn { self.report_purity_error( pc, callee_span, - #fmt["access to %s function", - pprust::purity_to_str(fn_ty.purity)]); + fmt!{"access to %s function", + pprust::purity_to_str(fn_ty.purity)}); } } } @@ -257,14 +257,14 @@ impl methods for check_loan_ctxt { (m_mutbl, m_imm) | (m_imm, m_mutbl) { self.bccx.span_err( new_loan.cmt.span, - #fmt["loan of %s as %s \ + fmt!{"loan of %s as %s \ conflicts with prior loan", self.bccx.cmt_to_str(new_loan.cmt), - self.bccx.mut_to_str(new_loan.mutbl)]); + self.bccx.mut_to_str(new_loan.mutbl)}); self.bccx.span_note( old_loan.cmt.span, - #fmt["prior loan as %s granted here", - self.bccx.mut_to_str(old_loan.mutbl)]); + fmt!{"prior loan as %s granted here", + self.bccx.mut_to_str(old_loan.mutbl)}); } } } @@ -294,8 +294,8 @@ impl methods for check_loan_ctxt { fn check_assignment(at: assignment_type, ex: @ast::expr) { let cmt = self.bccx.cat_expr(ex); - #debug["check_assignment(cmt=%s)", - self.bccx.cmt_to_repr(cmt)]; + debug!{"check_assignment(cmt=%s)", + self.bccx.cmt_to_repr(cmt)}; if self.in_ctor && self.is_self_field(cmt) && at.checked_by_liveness() { @@ -354,12 +354,12 @@ impl methods for check_loan_ctxt { m_imm { self.bccx.span_err( ex.span, - #fmt["%s prohibited due to outstanding loan", - at.ing_form(self.bccx.cmt_to_str(cmt))]); + fmt!{"%s prohibited due to outstanding loan", + at.ing_form(self.bccx.cmt_to_str(cmt))}); self.bccx.span_note( loan.cmt.span, - #fmt["loan of %s granted here", - self.bccx.cmt_to_str(loan.cmt)]); + fmt!{"loan of %s granted here", + self.bccx.cmt_to_str(loan.cmt)}); ret; } } @@ -386,17 +386,17 @@ impl methods for check_loan_ctxt { pc_pure_fn { self.tcx().sess.span_err( sp, - #fmt["%s prohibited in pure context", msg]); + fmt!{"%s prohibited in pure context", msg}); } pc_cmt(e) { if self.reported.insert(e.cmt.id, ()) { self.tcx().sess.span_err( e.cmt.span, - #fmt["illegal borrow unless pure: %s", - self.bccx.bckerr_code_to_str(e.code)]); + fmt!{"illegal borrow unless pure: %s", + self.bccx.bckerr_code_to_str(e.code)}); self.tcx().sess.span_note( sp, - #fmt["impure due to %s", msg]); + fmt!{"impure due to %s", msg}); } } } @@ -408,8 +408,8 @@ impl methods for check_loan_ctxt { } fn check_move_out_from_cmt(cmt: cmt) { - #debug["check_move_out_from_cmt(cmt=%s)", - self.bccx.cmt_to_repr(cmt)]; + debug!{"check_move_out_from_cmt(cmt=%s)", + self.bccx.cmt_to_repr(cmt)}; alt cmt.cat { // Rvalues, locals, and arguments can be moved: @@ -427,7 +427,7 @@ impl methods for check_loan_ctxt { _ { self.bccx.span_err( cmt.span, - #fmt["moving out of %s", self.bccx.cmt_to_str(cmt)]); + fmt!{"moving out of %s", self.bccx.cmt_to_str(cmt)}); ret; } } @@ -442,12 +442,12 @@ impl methods for check_loan_ctxt { for self.walk_loans_of(cmt.id, lp) |loan| { self.bccx.span_err( cmt.span, - #fmt["moving out of %s prohibited due to outstanding loan", - self.bccx.cmt_to_str(cmt)]); + fmt!{"moving out of %s prohibited due to outstanding loan", + self.bccx.cmt_to_str(cmt)}); self.bccx.span_note( loan.cmt.span, - #fmt["loan of %s granted here", - self.bccx.cmt_to_str(loan.cmt)]); + fmt!{"loan of %s granted here", + self.bccx.cmt_to_str(loan.cmt)}); ret; } } @@ -462,8 +462,8 @@ impl methods for check_loan_ctxt { some(lp) { lp } }; for self.walk_loans_of(cmt.id, lp) |_loan| { - #debug["Removing last use entry %? due to outstanding loan", - expr.id]; + debug!{"Removing last use entry %? due to outstanding loan", + expr.id}; self.bccx.last_use_map.remove(expr.id); ret; } @@ -507,7 +507,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk, sp: span, id: ast::node_id, &&self: check_loan_ctxt, visitor: visit::vt<check_loan_ctxt>) { - #debug["purity on entry=%?", copy self.declared_purity]; + debug!{"purity on entry=%?", copy self.declared_purity}; do save_and_restore(self.in_ctor) { do save_and_restore(self.declared_purity) { do save_and_restore(self.fn_args) { @@ -543,7 +543,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk, } } } - #debug["purity on exit=%?", copy self.declared_purity]; + debug!{"purity on exit=%?", copy self.declared_purity}; } fn check_loans_in_local(local: @ast::local, diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index 87e8ad7a9f2..4b9015eec67 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -90,7 +90,7 @@ fn req_loans_in_expr(ex: @ast::expr, let tcx = bccx.tcx; let old_root_ub = self.root_ub; - #debug["req_loans_in_expr(ex=%s)", pprust::expr_to_str(ex)]; + debug!{"req_loans_in_expr(ex=%s)", pprust::expr_to_str(ex)}; // If this expression is borrowed, have to ensure it remains valid: for tcx.borrowings.find(ex.id).each |borrow| { @@ -258,10 +258,10 @@ impl methods for gather_loan_ctxt { self.bccx.guaranteed_paths += 1; - #debug["guarantee_valid(cmt=%s, req_mutbl=%s, scope_r=%s)", + debug!{"guarantee_valid(cmt=%s, req_mutbl=%s, scope_r=%s)", self.bccx.cmt_to_repr(cmt), self.bccx.mut_to_str(req_mutbl), - region_to_str(self.tcx(), scope_r)]; + region_to_str(self.tcx(), scope_r)}; let _i = indenter(); alt cmt.lp { @@ -290,7 +290,7 @@ impl methods for gather_loan_ctxt { if self.tcx().sess.borrowck_note_loan() { self.bccx.span_note( cmt.span, - #fmt["immutable loan required"]); + fmt!{"immutable loan required"}); } } else { self.bccx.loaned_paths_same += 1; @@ -344,7 +344,7 @@ impl methods for gather_loan_ctxt { if self.tcx().sess.borrowck_note_pure() { self.bccx.span_note( cmt.span, - #fmt["purity required"]); + fmt!{"purity required"}); } } _ => { @@ -443,9 +443,9 @@ impl methods for gather_loan_ctxt { // in the alt, the id of `local(x)->@` is the `@y` pattern, // and the id of `local(x)->@->@` is the id of the `y` pattern. - #debug["gather_pat: id=%d pat=%s cmt=%s arm_id=%d alt_id=%d", + debug!{"gather_pat: id=%d pat=%s cmt=%s arm_id=%d alt_id=%d", pat.id, pprust::pat_to_str(pat), - self.bccx.cmt_to_repr(cmt), arm_id, alt_id]; + self.bccx.cmt_to_repr(cmt), arm_id, alt_id}; let _i = indenter(); let tcx = self.tcx(); @@ -463,8 +463,8 @@ impl methods for gather_loan_ctxt { .find(pat.id) { some(ast::def_variant(enum_did, _)) {enum_did} e {tcx.sess.span_bug(pat.span, - #fmt["resolved to %?, \ - not variant", e])} + fmt!{"resolved to %?, \ + not variant", e})} }; for subpats.each |subpat| { @@ -475,11 +475,11 @@ impl methods for gather_loan_ctxt { ast::pat_ident(_, none) if self.pat_is_variant(pat) { // nullary variant - #debug["nullary variant"]; + debug!{"nullary variant"}; } ast::pat_ident(id, o_pat) { // x or x @ p --- `x` must remain valid for the scope of the alt - #debug["defines identifier %s", pprust::path_to_str(id)]; + debug!{"defines identifier %s", pprust::path_to_str(id)}; // Note: there is a discussion of the function of // cat_discr in the method preserve(): diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs index 4b1726b69fa..b466cfd3a43 100644 --- a/src/rustc/middle/borrowck/loan.rs +++ b/src/rustc/middle/borrowck/loan.rs @@ -58,9 +58,9 @@ impl loan_methods for loan_ctxt { } fn loan(cmt: cmt, req_mutbl: ast::mutability) -> bckres<()> { - #debug["loan(%s, %s)", + debug!{"loan(%s, %s)", self.bccx.cmt_to_repr(cmt), - self.bccx.mut_to_str(req_mutbl)]; + self.bccx.mut_to_str(req_mutbl)}; let _i = indenter(); // see stable() above; should only be called when `cmt` is lendable diff --git a/src/rustc/middle/borrowck/preserve.rs b/src/rustc/middle/borrowck/preserve.rs index 860e4962295..e1e97c0dc6f 100644 --- a/src/rustc/middle/borrowck/preserve.rs +++ b/src/rustc/middle/borrowck/preserve.rs @@ -58,9 +58,9 @@ impl private_methods for &preserve_ctxt { fn tcx() -> ty::ctxt { self.bccx.tcx } fn preserve(cmt: cmt) -> bckres<preserve_condition> { - #debug["preserve(cmt=%s, root_ub=%?, root_managed_data=%b)", + debug!{"preserve(cmt=%s, root_ub=%?, root_managed_data=%b)", self.bccx.cmt_to_repr(cmt), self.root_ub, - self.root_managed_data]; + self.root_managed_data}; let _i = indenter(); alt cmt.cat { @@ -148,7 +148,7 @@ impl private_methods for &preserve_ctxt { // otherwise we have no guarantee the pointer will stay // live, so we must root the pointer (i.e., inc the ref // count) for the duration of the loan. - #debug["base.mutbl = %?", self.bccx.mut_to_str(base.mutbl)]; + debug!{"base.mutbl = %?", self.bccx.mut_to_str(base.mutbl)}; if base.mutbl == m_imm { let non_rooting_ctxt = preserve_ctxt({root_managed_data: false with **self}); @@ -157,12 +157,12 @@ impl private_methods for &preserve_ctxt { ok(pc_ok) } ok(pc_if_pure(_)) { - #debug["must root @T, otherwise purity req'd"]; + debug!{"must root @T, otherwise purity req'd"}; self.attempt_root(cmt, base, derefs) } err(e) => { - #debug["must root @T, err: %s", - self.bccx.bckerr_code_to_str(e.code)]; + debug!{"must root @T, err: %s", + self.bccx.bckerr_code_to_str(e.code)}; self.attempt_root(cmt, base, derefs) } } diff --git a/src/rustc/middle/capture.rs b/src/rustc/middle/capture.rs index 141ec29b5b2..b45d7d66e9e 100644 --- a/src/rustc/middle/capture.rs +++ b/src/rustc/middle/capture.rs @@ -43,16 +43,16 @@ fn check_capture_clause(tcx: ty::ctxt, if !vec::any(*freevars, |fv| fv.def == cap_def ) { tcx.sess.span_warn( cap_item.span, - #fmt("captured variable `%s` not used in closure", - *cap_item.name)); + fmt!{"captured variable `%s` not used in closure", + *cap_item.name}); } let cap_def_id = ast_util::def_id_of_def(cap_def).node; if !seen_defs.insert(cap_def_id, ()) { tcx.sess.span_err( cap_item.span, - #fmt("variable `%s` captured more than once", - *cap_item.name)); + fmt!{"variable `%s` captured more than once", + *cap_item.name}); } } } @@ -67,8 +67,8 @@ fn compute_capture_vars(tcx: ty::ctxt, // first add entries for anything explicitly named in the cap clause for (*cap_clause).each |cap_item| { - #debug("Doing capture var: %s (%?)", - *cap_item.name, cap_item.id); + debug!{"Doing capture var: %s (%?)", + *cap_item.name, cap_item.id}; let cap_def = tcx.def_map.get(cap_item.id); let cap_def_id = ast_util::def_id_of_def(cap_def).node; diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index 34529710825..8707cabfdf7 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -213,7 +213,7 @@ fn check_block(b: blk, cx: ctx, v: visit::vt<ctx>) { } fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { - #debug["kind::check_expr(%s)", expr_to_str(e)]; + debug!{"kind::check_expr(%s)", expr_to_str(e)}; alt e.node { expr_assign(_, ex) | expr_unary(box(_), ex) | expr_unary(uniq(_), ex) | @@ -296,10 +296,10 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { }; if vec::len(ts) != vec::len(*bounds) { // Fail earlier to make debugging easier - fail #fmt("Internal error: in kind::check_expr, length \ + fail fmt!{"Internal error: in kind::check_expr, length \ mismatch between actual and declared bounds: actual = \ %s (%u tys), declared = %? (%u tys)", - tys_to_str(cx.tcx, ts), ts.len(), *bounds, (*bounds).len()); + tys_to_str(cx.tcx, ts), ts.len(), *bounds, (*bounds).len()}; } do vec::iter2(ts, *bounds) |ty, bound| { check_bounds(cx, e.id, e.span, ty, bound) @@ -419,7 +419,7 @@ fn check_imm_free_var(cx: ctx, def: def, sp: span) { _ { cx.tcx.sess.span_bug( sp, - #fmt["unknown def for free variable: %?", def]); + fmt!{"unknown def for free variable: %?", def}); } } } @@ -510,7 +510,7 @@ fn check_cast_for_escaping_regions( some(ty::re_bound(*)) | some(ty::re_var(*)) => { cx.tcx.sess.span_bug( source.span, - #fmt["bad region found in kind: %?", target_substs.self_r]); + fmt!{"bad region found in kind: %?", target_substs.self_r}); } } diff --git a/src/rustc/middle/lang_items.rs b/src/rustc/middle/lang_items.rs index 07704de1297..d14d2d5a0c6 100644 --- a/src/rustc/middle/lang_items.rs +++ b/src/rustc/middle/lang_items.rs @@ -132,8 +132,8 @@ class LanguageItemCollector { some(original_def_id) if original_def_id != item_def_id => { - self.session.err(#fmt("duplicate entry for `%s`", - value)); + self.session.err(fmt!{"duplicate entry for `%s`", + value}); } some(_) | none => { // OK. @@ -191,7 +191,7 @@ class LanguageItemCollector { for self.item_refs.each |key, item_ref| { alt copy *item_ref { none => { - self.session.err(#fmt("no item found for `%s`", key)); + self.session.err(fmt!{"no item found for `%s`", key}); } some(did) => { // OK. diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index e047a525eb5..94be6865094 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -253,8 +253,8 @@ impl methods for ctxt { self.span_lint( new_ctxt.get_level(unrecognized_lint), meta.span, - #fmt("unknown `%s` attribute: `%s`", - level_to_str(level), *lintname)); + fmt!{"unknown `%s` attribute: `%s`", + level_to_str(level), *lintname}); } some(lint) { @@ -263,9 +263,9 @@ impl methods for ctxt { self.span_lint( forbid, meta.span, - #fmt("%s(%s) overruled by outer forbid(%s)", + fmt!{"%s(%s) overruled by outer forbid(%s)", level_to_str(level), - *lintname, *lintname)); + *lintname, *lintname}); } // we do multiple unneeded copies of the @@ -435,7 +435,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) { fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl, _body: ast::blk, span: span, id: ast::node_id) { - #debug["lint check_fn fk=%? id=%?", fk, id]; + debug!{"lint check_fn fk=%? id=%?", fk, id}; // don't complain about blocks, since they tend to get their modes // specified from the outside @@ -450,10 +450,10 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl, let mut counter = 0; do vec::iter2(fn_ty.inputs, decl.inputs) |arg_ty, arg_ast| { counter += 1; - #debug["arg %d, ty=%s, mode=%s", + debug!{"arg %d, ty=%s, mode=%s", counter, ty_to_str(tcx, arg_ty.ty), - mode_to_str(arg_ast.mode)]; + mode_to_str(arg_ast.mode)}; alt arg_ast.mode { ast::expl(ast::by_copy) => { /* always allow by-copy */ @@ -463,7 +463,7 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl, tcx.sess.span_lint( deprecated_mode, id, id, span, - #fmt["argument %d uses an explicit mode", counter]); + fmt!{"argument %d uses an explicit mode", counter}); } ast::infer(_) { @@ -472,9 +472,9 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl, tcx.sess.span_lint( deprecated_mode, id, id, span, - #fmt["argument %d uses the default mode \ + fmt!{"argument %d uses the default mode \ but shouldn't", - counter]); + counter}); } } } diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index 98bf1ac32bf..e7d88b9b2b8 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} } } // ______________________________________________________________________ @@ -243,7 +243,7 @@ class ir_maps { vec::push(self.lnks, lnk); self.num_live_nodes += 1u; - #debug["%s is of kind %?", ln.to_str(), lnk]; + debug!{"%s is of kind %?", ln.to_str(), lnk}; ln } @@ -252,7 +252,7 @@ class ir_maps { let ln = self.add_live_node(lnk); self.live_node_map.insert(node_id, ln); - #debug["%s is node %d", ln.to_str(), node_id]; + debug!{"%s is node %d", ln.to_str(), node_id}; } fn add_variable(vk: var_kind) -> variable { @@ -271,7 +271,7 @@ class ir_maps { } } - #debug["%s is %?", v.to_str(), vk]; + debug!{"%s is %?", v.to_str(), vk}; v } @@ -281,7 +281,7 @@ class ir_maps { some(var) {var} none { self.tcx.sess.span_bug( - span, #fmt("No variable registered for id %d", node_id)); + span, fmt!{"No variable registered for id %d", node_id}); } } } @@ -314,7 +314,7 @@ class ir_maps { fn add_last_use(expr_id: node_id, var: variable) { let vk = self.var_kinds[*var]; - #debug["Node %d is a last use of variable %?", expr_id, vk]; + debug!{"Node %d is a last use of variable %?", expr_id, vk}; alt vk { vk_arg(id, name, by_move) | vk_arg(id, name, by_copy) | @@ -332,7 +332,7 @@ class ir_maps { } vk_arg(_, _, by_ref) | vk_arg(_, _, by_mutbl_ref) | vk_arg(_, _, by_val) | vk_self | vk_field(_) | vk_implicit_ret { - #debug["--but it is not owned"]; + debug!{"--but it is not owned"}; } } } @@ -340,17 +340,17 @@ class ir_maps { fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span, id: node_id, &&self: @ir_maps, v: vt<@ir_maps>) { - #debug["visit_fn: id=%d", id]; + debug!{"visit_fn: id=%d", id}; let _i = util::common::indenter(); // swap in a new set of IR maps for this function body: let fn_maps = @ir_maps(self.tcx, self.method_map, self.last_use_map); - #debug["creating fn_maps: %x", ptr::addr_of(*fn_maps) as uint]; + debug!{"creating fn_maps: %x", ptr::addr_of(*fn_maps) as uint}; for decl.inputs.each |arg| { - #debug["adding argument %d", arg.id]; + debug!{"adding argument %d", arg.id}; let mode = ty::resolved_mode(self.tcx, arg.mode); (*fn_maps).add_variable(vk_arg(arg.id, arg.ident, mode)); }; @@ -405,7 +405,7 @@ fn add_class_fields(self: @ir_maps, did: def_id) { fn visit_local(local: @local, &&self: @ir_maps, vt: vt<@ir_maps>) { let def_map = self.tcx.def_map; do pat_util::pat_bindings(def_map, local.node.pat) |p_id, sp, path| { - #debug["adding local variable %d", p_id]; + debug!{"adding local variable %d", p_id}; let name = ast_util::path_to_ident(path); (*self).add_live_node_for_node(p_id, lnk_vdef(sp)); (*self).add_variable(vk_local(p_id, name)); @@ -418,7 +418,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) { // live nodes required for uses or definitions of variables: expr_path(_) { let def = self.tcx.def_map.get(expr.id); - #debug["expr %d: path that leads to %?", expr.id, def]; + debug!{"expr %d: path that leads to %?", expr.id, def}; if relevant_def(def).is_some() { (*self).add_live_node_for_node(expr.id, lnk_expr(expr.span)); } @@ -540,8 +540,8 @@ class liveness { // code have to agree about which AST nodes are worth // creating liveness nodes for. self.tcx.sess.span_bug( - span, #fmt["No live node registered for node %d", - node_id]); + span, fmt!{"No live node registered for node %d", + node_id}); } } } @@ -664,7 +664,7 @@ class liveness { wr.write_str(~"[ln("); wr.write_uint(*ln); wr.write_str(~") of kind "); - wr.write_str(#fmt["%?", copy self.ir.lnks[*ln]]); + wr.write_str(fmt!{"%?", copy self.ir.lnks[*ln]}); wr.write_str(~" reads"); self.write_vars(wr, ln, |idx| self.users[idx].reader ); wr.write_str(~" writes"); @@ -695,8 +695,8 @@ class liveness { self.indices2(ln, succ_ln, |idx, succ_idx| { self.users[idx] = self.users[succ_idx] }); - #debug["init_from_succ(ln=%s, succ=%s)", - self.ln_str(ln), self.ln_str(succ_ln)]; + debug!{"init_from_succ(ln=%s, succ=%s)", + self.ln_str(ln), self.ln_str(succ_ln)}; } fn merge_from_succ(ln: live_node, succ_ln: live_node, @@ -715,8 +715,8 @@ class liveness { } } - #debug["merge_from_succ(ln=%s, succ=%s, first_merge=%b, changed=%b)", - ln.to_str(), self.ln_str(succ_ln), first_merge, changed]; + debug!{"merge_from_succ(ln=%s, succ=%s, first_merge=%b, changed=%b)", + ln.to_str(), self.ln_str(succ_ln), first_merge, changed}; ret changed; fn copy_if_invalid(src: live_node, &dst: live_node) -> bool { @@ -738,8 +738,8 @@ class liveness { self.users[idx].reader = invalid_node(); self.users[idx].writer = invalid_node(); - #debug["%s defines %s (idx=%u): %s", writer.to_str(), var.to_str(), - idx, self.ln_str(writer)]; + debug!{"%s defines %s (idx=%u): %s", writer.to_str(), var.to_str(), + idx, self.ln_str(writer)}; } // Either read, write, or both depending on the acc bitset @@ -762,8 +762,8 @@ class liveness { self.users[idx].used = true; } - #debug["%s accesses[%x] %s: %s", - ln.to_str(), acc, var.to_str(), self.ln_str(ln)]; + debug!{"%s accesses[%x] %s: %s", + ln.to_str(), acc, var.to_str(), self.ln_str(ln)}; } // _______________________________________________________________________ @@ -778,14 +778,14 @@ class liveness { }); // hack to skip the loop unless #debug is enabled: - #debug["^^ liveness computation results for body %d (entry=%s)", + debug!{"^^ liveness computation results for body %d (entry=%s)", { for uint::range(0u, self.ir.num_live_nodes) |ln_idx| { #debug["%s", self.ln_str(live_node(ln_idx))]; } body.node.id }, - entry_ln.to_str()]; + entry_ln.to_str()}; entry_ln } @@ -1373,7 +1373,7 @@ fn check_local(local: @local, &&self: @liveness, vt: vt<@liveness>) { // No initializer: the variable might be unused; if not, it // should not be live at this point. - #debug["check_local() with no initializer"]; + debug!{"check_local() with no initializer"}; do (*self).pat_bindings(local.node.pat) |ln, var, sp| { if !self.warn_about_unused(sp, ln, var) { alt (*self).live_on_exit(ln, var) { @@ -1487,7 +1487,7 @@ impl check_methods for @liveness { none { /* ok */ } some(lnk_exit) { self.tcx.sess.span_err( - sp, #fmt["field `self.%s` is never initialized", *nm]); + sp, fmt!{"field `self.%s` is never initialized", *nm}); } some(lnk) { self.report_illegal_read( @@ -1525,8 +1525,8 @@ impl check_methods for @liveness { } fn check_move_from_var(span: span, ln: live_node, var: variable) { - #debug["check_move_from_var(%s, %s)", - ln.to_str(), var.to_str()]; + debug!{"check_move_from_var(%s, %s)", + ln.to_str(), var.to_str()}; alt (*self).live_on_exit(ln, var) { none { } @@ -1546,8 +1546,8 @@ impl check_methods for @liveness { } fn check_move_from_expr(expr: @expr, vt: vt<@liveness>) { - #debug["check_move_from_expr(node %d: %s)", - expr.id, expr_to_str(expr)]; + debug!{"check_move_from_expr(node %d: %s)", + expr.id, expr_to_str(expr)}; if self.ir.method_map.contains_key(expr.id) { // actually an rvalue, since this calls a method @@ -1643,7 +1643,7 @@ impl check_methods for @liveness { some(lnk) { self.tcx.sess.span_bug( orig_span, - #fmt["illegal writer: %?", lnk]); + fmt!{"illegal writer: %?", lnk}); } none {} } @@ -1662,14 +1662,14 @@ impl check_methods for @liveness { vk_arg(_, name, _) { self.tcx.sess.span_err( move_span, - #fmt["illegal move from argument `%s`, which is not \ - copy or move mode", *name]); + fmt!{"illegal move from argument `%s`, which is not \ + copy or move mode", *name}); ret; } vk_field(name) { self.tcx.sess.span_err( move_span, - #fmt["illegal move from field `%s`", *name]); + fmt!{"illegal move from field `%s`", *name}); ret; } vk_self { @@ -1682,8 +1682,8 @@ impl check_methods for @liveness { vk_local(*) | vk_implicit_ret { self.tcx.sess.span_bug( move_span, - #fmt["illegal reader (%?) for `%?`", - lnk, vk]); + fmt!{"illegal reader (%?) for `%?`", + lnk, vk}); } } } @@ -1708,18 +1708,18 @@ impl check_methods for @liveness { lnk_freevar(span) { self.tcx.sess.span_err( span, - #fmt["capture of %s: `%s`", msg, *name]); + fmt!{"capture of %s: `%s`", msg, *name}); } lnk_expr(span) { self.tcx.sess.span_err( span, - #fmt["use of %s: `%s`", msg, *name]); + fmt!{"use of %s: `%s`", msg, *name}); } lnk_exit | lnk_vdef(_) { self.tcx.sess.span_bug( chk_span, - #fmt["illegal reader: %?", lnk]); + fmt!{"illegal reader: %?", lnk}); } } } @@ -1776,11 +1776,11 @@ impl check_methods for @liveness { if is_assigned { self.tcx.sess.span_warn( - sp, #fmt["variable `%s` is assigned to, \ - but never used", *name]); + sp, fmt!{"variable `%s` is assigned to, \ + but never used", *name}); } else { self.tcx.sess.span_warn( - sp, #fmt["unused variable: `%s`", *name]); + sp, fmt!{"unused variable: `%s`", *name}); } } ret true; @@ -1793,7 +1793,7 @@ impl check_methods for @liveness { for self.should_warn(var).each |name| { self.tcx.sess.span_warn( sp, - #fmt["value assigned to `%s` is never read", *name]); + fmt!{"value assigned to `%s` is never read", *name}); } } } diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index d0dc1ea28f7..e6b2209b44a 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -187,7 +187,7 @@ fn record_parent(cx: ctxt, child_id: ast::node_id) { alt cx.parent { none { /* no-op */ } some(parent_id) { - #debug["parent of node %d is node %d", child_id, parent_id]; + debug!{"parent of node %d is node %d", child_id, parent_id}; cx.region_map.insert(child_id, parent_id); } } @@ -232,11 +232,11 @@ fn resolve_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) { let mut new_cx = cx; alt expr.node { ast::expr_call(*) => { - #debug["node %d: %s", expr.id, pprust::expr_to_str(expr)]; + debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr)}; new_cx.parent = some(expr.id); } ast::expr_alt(subexpr, _, _) => { - #debug["node %d: %s", expr.id, pprust::expr_to_str(expr)]; + debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr)}; new_cx.parent = some(expr.id); } ast::expr_fn(_, _, _, cap_clause) | @@ -289,9 +289,9 @@ fn resolve_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk, } }; - #debug["visiting fn with body %d. cx.parent: %? \ + debug!{"visiting fn with body %d. cx.parent: %? \ fn_cx.parent: %?", - body.node.id, cx.parent, fn_cx.parent]; + body.node.id, cx.parent, fn_cx.parent}; for decl.inputs.each |input| { cx.region_map.insert(input.id, body.node.id); @@ -367,19 +367,19 @@ impl methods for determine_rp_ctxt { fn add_rp(id: ast::node_id) { assert id != 0; if self.region_paramd_items.insert(id, ()) { - #debug["add region-parameterized item: %d (%s)", - id, ast_map::node_id_to_str(self.ast_map, id)]; + debug!{"add region-parameterized item: %d (%s)", + id, ast_map::node_id_to_str(self.ast_map, id)}; self.worklist.push(id); } else { - #debug["item %d already region-parameterized", id]; + debug!{"item %d already region-parameterized", id}; } } fn add_dep(from: ast::node_id, to: ast::node_id) { - #debug["add dependency from %d -> %d (%s -> %s)", + debug!{"add dependency from %d -> %d (%s -> %s)", from, to, ast_map::node_id_to_str(self.ast_map, from), - ast_map::node_id_to_str(self.ast_map, to)]; + ast_map::node_id_to_str(self.ast_map, to)}; let vec = alt self.dep_map.find(from) { some(vec) => {vec} none => { @@ -436,7 +436,7 @@ impl methods for determine_rp_ctxt { let old_anon_implies_rp = self.anon_implies_rp; self.item_id = item_id; self.anon_implies_rp = anon_implies_rp; - #debug["with_item_id(%d, %b)", item_id, anon_implies_rp]; + debug!{"with_item_id(%d, %b)", item_id, anon_implies_rp}; let _i = util::common::indenter(); f(); self.item_id = old_item_id; @@ -488,7 +488,7 @@ fn determine_rp_in_ty(ty: @ast::ty, alt ty.node { ast::ty_rptr(r, _) | ast::ty_path(@{rp: some(r), _}, _) => { - #debug["referenced type with regions %s", pprust::ty_to_str(ty)]; + debug!{"referenced type with regions %s", pprust::ty_to_str(ty)}; if cx.region_is_relevant(r) { cx.add_rp(cx.item_id); } @@ -510,8 +510,8 @@ fn determine_rp_in_ty(ty: @ast::ty, } else { let cstore = cx.sess.cstore; if csearch::get_region_param(cstore, did) { - #debug["reference to external, rp'd type %s", - pprust::ty_to_str(ty)]; + debug!{"reference to external, rp'd type %s", + pprust::ty_to_str(ty)}; cx.add_rp(cx.item_id); } } @@ -560,7 +560,7 @@ fn determine_rp_in_crate(sess: session, // propagate indirect dependencies while cx.worklist.len() != 0 { let id = cx.worklist.pop(); - #debug["popped %d from worklist", id]; + debug!{"popped %d from worklist", id}; alt cx.dep_map.find(id) { none {} some(vec) { diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs index c49a6889f05..1965d5289be 100644 --- a/src/rustc/middle/resolve3.rs +++ b/src/rustc/middle/resolve3.rs @@ -1218,9 +1218,9 @@ class Resolver { if self.block_needs_anonymous_module(block) { let block_id = block.node.id; - #debug("(building reduced graph for block) creating a new \ + debug!{"(building reduced graph for block) creating a new \ anonymous module for block %d", - block_id); + block_id}; let parent_module = self.get_module_from_parent(parent); let new_module = @Module(BlockParentLink(parent_module, block_id), @@ -1245,10 +1245,10 @@ class Resolver { for each_path(self.session.cstore, get(root.def_id).crate) |path_entry| { - #debug("(building reduced graph for external crate) found path \ + debug!{"(building reduced graph for external crate) found path \ entry: %s (%?)", path_entry.path_string, - path_entry.def_like); + path_entry.def_like}; let mut pieces = split_str(path_entry.path_string, ~"::"); let final_ident = pop(pieces); @@ -1267,8 +1267,8 @@ class Resolver { // Define or reuse the module node. alt child_name_bindings.module_def { NoModuleDef { - #debug("(building reduced graph for external crate) \ - autovivifying %s", ident); + debug!{"(building reduced graph for external crate) \ + autovivifying %s", ident}; let parent_link = self.get_parent_link(new_parent, atom); (*child_name_bindings).define_module(parent_link, @@ -1292,9 +1292,9 @@ class Resolver { def_mod(def_id) | def_foreign_mod(def_id) { alt copy child_name_bindings.module_def { NoModuleDef { - #debug("(building reduced graph for \ + debug!{"(building reduced graph for \ external crate) building module \ - %s", final_ident); + %s", final_ident}; let parent_link = self.get_parent_link(new_parent, atom); @@ -1339,10 +1339,10 @@ class Resolver { } } - #debug("(building reduced graph \ + debug!{"(building reduced graph \ for external crate) \ ... creating import \ - resolution"); + resolution"}; new_parent.import_resolutions. insert(atom, resolution); @@ -1350,9 +1350,9 @@ class Resolver { } } ModuleDef(module) { - #debug("(building reduced graph for \ + debug!{"(building reduced graph for \ external crate) already created \ - module"); + module"}; module.def_id = some(def_id); modules.insert(def_id, module); } @@ -1360,13 +1360,13 @@ class Resolver { } def_fn(def_id, _) | def_const(def_id) | def_variant(_, def_id) { - #debug("(building reduced graph for external \ - crate) building value %s", final_ident); + debug!{"(building reduced graph for external \ + crate) building value %s", final_ident}; (*child_name_bindings).define_value(def); } def_ty(def_id) { - #debug("(building reduced graph for external \ - crate) building type %s", final_ident); + debug!{"(building reduced graph for external \ + crate) building type %s", final_ident}; // If this is a trait, add all the method names // to the trait info. @@ -1380,10 +1380,10 @@ class Resolver { let interned_method_names = @atom_hashmap(); for method_names.each |method_name| { - #debug("(building reduced graph for \ + debug!{"(building reduced graph for \ external crate) ... adding \ trait method '%?'", - method_name); + method_name}; let atom = (*self.atom_table).intern (method_name); @@ -1398,10 +1398,10 @@ class Resolver { (*child_name_bindings).define_type(def); } def_class(def_id, has_constructor) { - #debug("(building reduced graph for external \ + debug!{"(building reduced graph for external \ crate) building type %s (value? %d)", final_ident, - if has_constructor { 1 } else { 0 }); + if has_constructor { 1 } else { 0 }}; (*child_name_bindings).define_type(def); if has_constructor { @@ -1412,7 +1412,7 @@ class Resolver { def_prim_ty(*) | def_ty_param(*) | def_binding(*) | def_use(*) | def_upvar(*) | def_region(*) | def_typaram_binder(*) { - fail #fmt("didn't expect `%?`", def); + fail fmt!{"didn't expect `%?`", def}; } } } @@ -1421,12 +1421,12 @@ class Resolver { // written, we can't process this impl now. We'll get it // later. - #debug("(building reduced graph for external crate) \ - ignoring impl %s", final_ident); + debug!{"(building reduced graph for external crate) \ + ignoring impl %s", final_ident}; } dl_field { - #debug("(building reduced graph for external crate) \ - ignoring field %s", final_ident); + debug!{"(building reduced graph for external crate) \ + ignoring field %s", final_ident}; } } } @@ -1462,16 +1462,16 @@ class Resolver { // by the fact that they have no def ID, which we do here in order to // skip them. - #debug("(building reduced graph for impls in external crate) looking \ + debug!{"(building reduced graph for impls in external crate) looking \ for impls in `%s` (%?)", self.module_to_str(module), - copy module.def_id); + copy module.def_id}; alt module.def_id { none { - #debug("(building reduced graph for impls in external \ + debug!{"(building reduced graph for impls in external \ module) no def ID for `%s`, skipping", - self.module_to_str(module)); + self.module_to_str(module)}; ret; } some(_) { @@ -1492,11 +1492,11 @@ class Resolver { } def_ids.insert(implementation.did, ()); - #debug("(building reduced graph for impls in external module) \ + debug!{"(building reduced graph for impls in external module) \ added impl `%s` (%?) to `%s`", *implementation.ident, implementation.did, - self.module_to_str(module)); + self.module_to_str(module)}; let name = (*self.atom_table).intern(implementation.ident); @@ -1559,14 +1559,14 @@ class Resolver { let mut i = 0u; let mut prev_unresolved_imports = 0u; loop { - #debug("(resolving imports) iteration %u, %u imports left", - i, self.unresolved_imports); + debug!{"(resolving imports) iteration %u, %u imports left", + i, self.unresolved_imports}; let module_root = (*self.graph_root).get_module(); self.resolve_imports_for_module_subtree(module_root); if self.unresolved_imports == 0u { - #debug("(resolving imports) success"); + debug!{"(resolving imports) success"}; break; } @@ -1586,8 +1586,8 @@ class Resolver { * submodules. */ fn resolve_imports_for_module_subtree(module: @Module) { - #debug("(resolving imports for module subtree) resolving %s", - self.module_to_str(module)); + debug!{"(resolving imports for module subtree) resolving %s", + self.module_to_str(module)}; self.resolve_imports_for_module(module); for module.children.each |_name, child_node| { @@ -1609,9 +1609,9 @@ class Resolver { /// Attempts to resolve imports for the given module only. fn resolve_imports_for_module(module: @Module) { if (*module).all_imports_resolved() { - #debug("(resolving imports for module) all imports resolved for \ + debug!{"(resolving imports for module) all imports resolved for \ %s", - self.module_to_str(module)); + self.module_to_str(module)}; ret; } @@ -1652,10 +1652,10 @@ class Resolver { let mut resolution_result; let module_path = import_directive.module_path; - #debug("(resolving import for module) resolving import `%s::...` in \ + debug!{"(resolving import for module) resolving import `%s::...` in \ `%s`", *(*self.atom_table).atoms_to_str((*module_path).get()), - self.module_to_str(module)); + self.module_to_str(module)}; // One-level renaming imports of the form `import foo = bar;` are // handled specially. @@ -1736,16 +1736,16 @@ class Resolver { target: Atom, source: Atom) -> ResolveResult<()> { - #debug("(resolving single import) resolving `%s` = `%s::%s` from \ + debug!{"(resolving single import) resolving `%s` = `%s::%s` from \ `%s`", *(*self.atom_table).atom_to_str(target), self.module_to_str(containing_module), *(*self.atom_table).atom_to_str(source), - self.module_to_str(module)); + self.module_to_str(module)}; if !self.name_is_exported(containing_module, source) { - #debug("(resolving single import) name `%s` is unexported", - *(*self.atom_table).atom_to_str(source)); + debug!{"(resolving single import) name `%s` is unexported", + *(*self.atom_table).atom_to_str(source)}; ret Failed; } @@ -1800,8 +1800,8 @@ class Resolver { // able to resolve this import. if containing_module.glob_count > 0u { - #debug("(resolving single import) unresolved glob; \ - bailing out"); + debug!{"(resolving single import) unresolved glob; \ + bailing out"}; ret Indeterminate; } @@ -1883,8 +1883,8 @@ class Resolver { } some(_) { // The import is unresolved. Bail out. - #debug("(resolving single import) unresolved import; \ - bailing out"); + debug!{"(resolving single import) unresolved import; \ + bailing out"}; ret Indeterminate; } } @@ -1897,13 +1897,13 @@ class Resolver { alt module_result { BoundResult(target_module, name_bindings) { - #debug("(resolving single import) found module binding"); + debug!{"(resolving single import) found module binding"}; import_resolution.module_target = some(Target(target_module, name_bindings)); } UnboundResult { - #debug("(resolving single import) didn't find module \ - binding"); + debug!{"(resolving single import) didn't find module \ + binding"}; } UnknownResult { fail ~"module result should be known at this point"; @@ -1954,7 +1954,7 @@ class Resolver { assert import_resolution.outstanding_references >= 1u; import_resolution.outstanding_references -= 1u; - #debug("(resolving single import) successfully resolved import"); + debug!{"(resolving single import) successfully resolved import"}; ret Success(()); } @@ -1976,8 +1976,8 @@ class Resolver { // (including globs). if !(*containing_module).all_imports_resolved() { - #debug("(resolving glob import) target module has unresolved \ - imports; bailing out"); + debug!{"(resolving glob import) target module has unresolved \ + imports; bailing out"}; ret Indeterminate; } @@ -1988,15 +1988,15 @@ class Resolver { |atom, target_import_resolution| { if !self.name_is_exported(containing_module, atom) { - #debug("(resolving glob import) name `%s` is unexported", - *(*self.atom_table).atom_to_str(atom)); + debug!{"(resolving glob import) name `%s` is unexported", + *(*self.atom_table).atom_to_str(atom)}; again; } - #debug("(resolving glob import) writing module resolution \ + debug!{"(resolving glob import) writing module resolution \ %? into `%s`", is_none(target_import_resolution.module_target), - self.module_to_str(module)); + self.module_to_str(module)}; // Here we merge two import resolutions. alt module.import_resolutions.find(atom) { @@ -2065,8 +2065,8 @@ class Resolver { // Add all children from the containing module. for containing_module.children.each |atom, name_bindings| { if !self.name_is_exported(containing_module, atom) { - #debug("(resolving glob import) name `%s` is unexported", - *(*self.atom_table).atom_to_str(atom)); + debug!{"(resolving glob import) name `%s` is unexported", + *(*self.atom_table).atom_to_str(atom)}; again; } @@ -2084,36 +2084,36 @@ class Resolver { } - #debug("(resolving glob import) writing resolution `%s` in `%s` \ + debug!{"(resolving glob import) writing resolution `%s` in `%s` \ to `%s`", *(*self.atom_table).atom_to_str(atom), self.module_to_str(containing_module), - self.module_to_str(module)); + self.module_to_str(module)}; // Merge the child item into the import resolution. if (*name_bindings).defined_in_namespace(ModuleNS) { - #debug("(resolving glob import) ... for module target"); + debug!{"(resolving glob import) ... for module target"}; dest_import_resolution.module_target = some(Target(containing_module, name_bindings)); } if (*name_bindings).defined_in_namespace(ValueNS) { - #debug("(resolving glob import) ... for value target"); + debug!{"(resolving glob import) ... for value target"}; dest_import_resolution.value_target = some(Target(containing_module, name_bindings)); } if (*name_bindings).defined_in_namespace(TypeNS) { - #debug("(resolving glob import) ... for type target"); + debug!{"(resolving glob import) ... for type target"}; dest_import_resolution.type_target = some(Target(containing_module, name_bindings)); } if (*name_bindings).defined_in_namespace(ImplNS) { - #debug("(resolving glob import) ... for impl target"); + debug!{"(resolving glob import) ... for impl target"}; (*dest_import_resolution.impl_target).push (@Target(containing_module, name_bindings)); } } - #debug("(resolving glob import) successfully resolved import"); + debug!{"(resolving glob import) successfully resolved import"}; ret Success(()); } @@ -2142,9 +2142,9 @@ class Resolver { ret Failed; } Indeterminate { - #debug("(resolving module path for import) module \ + debug!{"(resolving module path for import) module \ resolution is indeterminate: %s", - *(*self.atom_table).atom_to_str(name)); + *(*self.atom_table).atom_to_str(name)}; ret Indeterminate; } Success(target) { @@ -2152,9 +2152,9 @@ class Resolver { NoModuleDef { // Not a module. self.session.span_err(span, - #fmt("not a module: %s", + fmt!{"not a module: %s", *(*self.atom_table). - atom_to_str(name))); + atom_to_str(name)}); ret Failed; } ModuleDef(module) { @@ -2183,10 +2183,10 @@ class Resolver { let module_path_len = (*module_path).len(); assert module_path_len > 0u; - #debug("(resolving module path for import) processing `%s` rooted at \ + debug!{"(resolving module path for import) processing `%s` rooted at \ `%s`", *(*self.atom_table).atoms_to_str((*module_path).get()), - self.module_to_str(module)); + self.module_to_str(module)}; // The first element of the module path must be in the current scope // chain. @@ -2199,8 +2199,8 @@ class Resolver { ret Failed; } Indeterminate { - #debug("(resolving module path for import) indeterminate; \ - bailing"); + debug!{"(resolving module path for import) indeterminate; \ + bailing"}; ret Indeterminate; } Success(resulting_module) { @@ -2220,11 +2220,11 @@ class Resolver { namespace: Namespace) -> ResolveResult<Target> { - #debug("(resolving item in lexical scope) resolving `%s` in \ + debug!{"(resolving item in lexical scope) resolving `%s` in \ namespace %? in `%s`", *(*self.atom_table).atom_to_str(name), namespace, - self.module_to_str(module)); + self.module_to_str(module)}; // The current module node is handled specially. First, check for // its immediate children. @@ -2251,9 +2251,9 @@ class Resolver { alt (*import_resolution).target_for_namespace(namespace) { none { // Not found; continue. - #debug("(resolving item in lexical scope) found \ + debug!{"(resolving item in lexical scope) found \ import resolution, but not in namespace %?", - namespace); + namespace}; } some(target) { import_resolution.used = true; @@ -2270,8 +2270,8 @@ class Resolver { alt search_module.parent_link { NoParentLink { // No more parents. This module was unresolved. - #debug("(resolving item in lexical scope) unresolved \ - module"); + debug!{"(resolving item in lexical scope) unresolved \ + module"}; ret Failed; } ModuleParentLink(parent_module_node, _) | @@ -2290,8 +2290,8 @@ class Resolver { // We couldn't see through the higher scope because of an // unresolved import higher up. Bail. - #debug("(resolving item in lexical scope) indeterminate \ - higher scope; bailing"); + debug!{"(resolving item in lexical scope) indeterminate \ + higher scope; bailing"}; ret Indeterminate; } Success(target) { @@ -2309,8 +2309,8 @@ class Resolver { Success(target) { alt target.bindings.module_def { NoModuleDef { - #error("!!! (resolving module in lexical scope) module - wasn't actually a module!"); + error!{"!!! (resolving module in lexical scope) module + wasn't actually a module!"}; ret Failed; } ModuleDef(module) { @@ -2319,13 +2319,13 @@ class Resolver { } } Indeterminate { - #debug("(resolving module in lexical scope) indeterminate; \ - bailing"); + debug!{"(resolving module in lexical scope) indeterminate; \ + bailing"}; ret Indeterminate; } Failed { - #debug("(resolving module in lexical scope) failed to \ - resolve"); + debug!{"(resolving module in lexical scope) failed to \ + resolve"}; ret Failed; } } @@ -2347,13 +2347,13 @@ class Resolver { xray: XrayFlag) -> ResolveResult<Target> { - #debug("(resolving name in module) resolving `%s` in `%s`", + debug!{"(resolving name in module) resolving `%s` in `%s`", *(*self.atom_table).atom_to_str(name), - self.module_to_str(module)); + self.module_to_str(module)}; if xray == NoXray && !self.name_is_exported(module, name) { - #debug("(resolving name in module) name `%s` is unexported", - *(*self.atom_table).atom_to_str(name)); + debug!{"(resolving name in module) name `%s` is unexported", + *(*self.atom_table).atom_to_str(name)}; ret Failed; } @@ -2362,7 +2362,7 @@ class Resolver { some(name_bindings) if (*name_bindings).defined_in_namespace(namespace) { - #debug("(resolving name in module) found node as child"); + debug!{"(resolving name in module) found node as child"}; ret Success(Target(module, name_bindings)); } some(_) | none { @@ -2374,7 +2374,7 @@ class Resolver { // we bail out; we don't know its imports yet. if module.glob_count > 0u { - #debug("(resolving name in module) module has glob; bailing out"); + debug!{"(resolving name in module) module has glob; bailing out"}; ret Indeterminate; } @@ -2382,20 +2382,20 @@ class Resolver { alt module.import_resolutions.find(name) { some(import_resolution) { if import_resolution.outstanding_references != 0u { - #debug("(resolving name in module) import unresolved; \ - bailing out"); + debug!{"(resolving name in module) import unresolved; \ + bailing out"}; ret Indeterminate; } alt (*import_resolution).target_for_namespace(namespace) { none { - #debug("(resolving name in module) name found, but \ + debug!{"(resolving name in module) name found, but \ not in namespace %?", - namespace); + namespace}; } some(target) { - #debug("(resolving name in module) resolved to \ - import"); + debug!{"(resolving name in module) resolved to \ + import"}; import_resolution.used = true; ret Success(copy target); } @@ -2407,8 +2407,8 @@ class Resolver { } // We're out of luck. - #debug("(resolving name in module) failed to resolve %s", - *(*self.atom_table).atom_to_str(name)); + debug!{"(resolving name in module) failed to resolve %s", + *(*self.atom_table).atom_to_str(name)}; ret Failed; } @@ -2433,81 +2433,81 @@ class Resolver { } } - #debug("(resolving one-level naming result) resolving import `%s` = \ + debug!{"(resolving one-level naming result) resolving import `%s` = \ `%s` in `%s`", *(*self.atom_table).atom_to_str(target_name), *(*self.atom_table).atom_to_str(source_name), - self.module_to_str(module)); + self.module_to_str(module)}; // Find the matching items in the lexical scope chain for every // namespace. If any of them come back indeterminate, this entire // import is indeterminate. let mut module_result; - #debug("(resolving one-level naming result) searching for module"); + debug!{"(resolving one-level naming result) searching for module"}; alt self.resolve_item_in_lexical_scope(module, source_name, ModuleNS) { Failed { - #debug("(resolving one-level renaming import) didn't find \ - module result"); + debug!{"(resolving one-level renaming import) didn't find \ + module result"}; module_result = none; } Indeterminate { - #debug("(resolving one-level renaming import) module result \ - is indeterminate; bailing"); + debug!{"(resolving one-level renaming import) module result \ + is indeterminate; bailing"}; ret Indeterminate; } Success(name_bindings) { - #debug("(resolving one-level renaming import) module result \ - found"); + debug!{"(resolving one-level renaming import) module result \ + found"}; module_result = some(copy name_bindings); } } let mut value_result; - #debug("(resolving one-level naming result) searching for value"); + debug!{"(resolving one-level naming result) searching for value"}; alt self.resolve_item_in_lexical_scope(module, source_name, ValueNS) { Failed { - #debug("(resolving one-level renaming import) didn't find \ - value result"); + debug!{"(resolving one-level renaming import) didn't find \ + value result"}; value_result = none; } Indeterminate { - #debug("(resolving one-level renaming import) value result \ - is indeterminate; bailing"); + debug!{"(resolving one-level renaming import) value result \ + is indeterminate; bailing"}; ret Indeterminate; } Success(name_bindings) { - #debug("(resolving one-level renaming import) value result \ - found"); + debug!{"(resolving one-level renaming import) value result \ + found"}; value_result = some(copy name_bindings); } } let mut type_result; - #debug("(resolving one-level naming result) searching for type"); + debug!{"(resolving one-level naming result) searching for type"}; alt self.resolve_item_in_lexical_scope(module, source_name, TypeNS) { Failed { - #debug("(resolving one-level renaming import) didn't find \ - type result"); + debug!{"(resolving one-level renaming import) didn't find \ + type result"}; type_result = none; } Indeterminate { - #debug("(resolving one-level renaming import) type result is \ - indeterminate; bailing"); + debug!{"(resolving one-level renaming import) type result is \ + indeterminate; bailing"}; ret Indeterminate; } Success(name_bindings) { - #debug("(resolving one-level renaming import) type result \ - found"); + debug!{"(resolving one-level renaming import) type result \ + found"}; type_result = some(copy name_bindings); } } @@ -2530,24 +2530,24 @@ class Resolver { // let mut impl_result; - #debug("(resolving one-level naming result) searching for impl"); + debug!{"(resolving one-level naming result) searching for impl"}; alt self.resolve_item_in_lexical_scope(module, source_name, ImplNS) { Failed { - #debug("(resolving one-level renaming import) didn't find \ - impl result"); + debug!{"(resolving one-level renaming import) didn't find \ + impl result"}; impl_result = none; } Indeterminate { - #debug("(resolving one-level renaming import) impl result is \ - indeterminate; bailing"); + debug!{"(resolving one-level renaming import) impl result is \ + indeterminate; bailing"}; ret Indeterminate; } Success(name_bindings) { - #debug("(resolving one-level renaming import) impl result \ - found"); + debug!{"(resolving one-level renaming import) impl result \ + found"}; impl_result = some(@copy name_bindings); } } @@ -2569,11 +2569,11 @@ class Resolver { import resolution name by now"; } some(import_resolution) { - #debug("(resolving one-level renaming import) writing module \ + debug!{"(resolving one-level renaming import) writing module \ result %? for `%s` into `%s`", is_none(module_result), *(*self.atom_table).atom_to_str(target_name), - self.module_to_str(module)); + self.module_to_str(module)}; import_resolution.module_target = module_result; import_resolution.value_target = value_result; @@ -2593,7 +2593,7 @@ class Resolver { } } - #debug("(resolving one-level renaming import) successfully resolved"); + debug!{"(resolving one-level renaming import) successfully resolved"}; ret Success(()); } @@ -2649,9 +2649,9 @@ class Resolver { } some(_) { // Bail out. - #debug("(recording exports for module subtree) not recording \ + debug!{"(recording exports for module subtree) not recording \ exports for `%s`", - self.module_to_str(module)); + self.module_to_str(module)}; ret; } } @@ -2735,9 +2735,9 @@ class Resolver { } some(_) { // Bail out. - #debug("(building impl scopes for module subtree) not \ + debug!{"(building impl scopes for module subtree) not \ resolving implementations for `%s`", - self.module_to_str(module)); + self.module_to_str(module)}; ret; } } @@ -2763,9 +2763,9 @@ class Resolver { fn build_impl_scope_for_module(module: @Module) { let mut impl_scope = ~[]; - #debug("(building impl scope for module) processing module %s (%?)", + debug!{"(building impl scope for module) processing module %s (%?)", self.module_to_str(module), - copy module.def_id); + copy module.def_id}; // Gather up all direct children implementations in the module. for module.children.each |_impl_name, child_name_bindings| { @@ -2774,20 +2774,20 @@ class Resolver { } } - #debug("(building impl scope for module) found %u impl(s) as direct \ + debug!{"(building impl scope for module) found %u impl(s) as direct \ children", - impl_scope.len()); + impl_scope.len()}; // Gather up all imports. for module.import_resolutions.each |_impl_name, import_resolution| { for (*import_resolution.impl_target).each |impl_target| { - #debug("(building impl scope for module) found impl def"); + debug!{"(building impl scope for module) found impl def"}; impl_scope += impl_target.bindings.impl_defs; } } - #debug("(building impl scope for module) found %u impl(s) in total", - impl_scope.len()); + debug!{"(building impl scope for module) found %u impl(s) in total", + impl_scope.len()}; // Determine the parent's implementation scope. let mut parent_impl_scopes; @@ -2840,17 +2840,17 @@ class Resolver { some(name) { alt orig_module.children.find(name) { none { - #debug("!!! (with scope) didn't find `%s` in `%s`", + debug!{"!!! (with scope) didn't find `%s` in `%s`", *(*self.atom_table).atom_to_str(name), - self.module_to_str(orig_module)); + self.module_to_str(orig_module)}; } some(name_bindings) { alt (*name_bindings).get_module_if_available() { none { - #debug("!!! (with scope) didn't find module \ + debug!{"!!! (with scope) didn't find module \ for `%s` in `%s`", *(*self.atom_table).atom_to_str(name), - self.module_to_str(orig_module)); + self.module_to_str(orig_module)}; } some(module) { self.current_module = module; @@ -2995,7 +2995,7 @@ class Resolver { // XXX: This shouldn't be unsafe! fn resolve_crate() unsafe { - #debug("(resolving crate) starting"); + debug!{"(resolving crate) starting"}; // To avoid a failure in metadata encoding later, we have to add the // crate-level implementation scopes @@ -3022,7 +3022,7 @@ class Resolver { } fn resolve_item(item: @item, visitor: ResolveVisitor) { - #debug("(resolving item) resolving %s", *item.ident); + debug!{"(resolving item) resolving %s", *item.ident}; // Items with the !resolve_unexported attribute are X-ray contexts. // This is used to allow the test runner to run unexported tests. @@ -3198,8 +3198,8 @@ class Resolver { for (*type_parameters).eachi |index, type_parameter| { let name = (*self.atom_table).intern(type_parameter.ident); - #debug("with_type_parameter_rib: %d %d", node_id, - type_parameter.id); + debug!{"with_type_parameter_rib: %d %d", node_id, + type_parameter.id}; let def_like = dl_def(def_ty_param (local_def(type_parameter.id), index + initial_index)); @@ -3304,8 +3304,8 @@ class Resolver { self.resolve_type(argument.ty, visitor); - #debug("(resolving function) recorded argument `%s`", - *(*self.atom_table).atom_to_str(name)); + debug!{"(resolving function) recorded argument `%s`", + *(*self.atom_table).atom_to_str(name)}; } self.resolve_type(declaration.output, visitor); @@ -3315,7 +3315,7 @@ class Resolver { // Resolve the function body. self.resolve_block(block, visitor); - #debug("(resolving function) leaving function"); + debug!{"(resolving function) leaving function"}; } (*self.value_ribs).pop(); @@ -3372,7 +3372,7 @@ class Resolver { // definition of the interface into the definition // map. - #debug("(resolving class) found trait def: %?", def); + debug!{"(resolving class) found trait def: %?", def}; self.record_def(interface.ref_id, def); @@ -3530,7 +3530,7 @@ class Resolver { visitor: ResolveVisitor) { // Write the implementations in scope into the module metadata. - #debug("(resolving module) resolving module ID %d", id); + debug!{"(resolving module) resolving module ID %d", id}; self.impl_map.insert(id, self.current_module.impl_scopes); visit_mod(module, span, id, (), visitor); @@ -3577,9 +3577,9 @@ class Resolver { */ for arm.pats.each |p| { do pat_util::pat_bindings(self.def_map, p) |_id, sp, pth| { - self.session.span_note(sp, #fmt("Treating %s as a variable \ + self.session.span_note(sp, fmt!{"Treating %s as a variable \ binding, because it does not denote any variant in scope", - path_to_str(pth))); + path_to_str(pth)}); } }; } @@ -3616,7 +3616,7 @@ class Resolver { } fn resolve_block(block: blk, visitor: ResolveVisitor) { - #debug("(resolving block) entering block"); + debug!{"(resolving block) entering block"}; (*self.value_ribs).push(@Rib(NormalRibKind)); // Move down in the graph, if there's an anonymous module rooted here. @@ -3624,8 +3624,8 @@ class Resolver { alt self.current_module.anonymous_children.find(block.node.id) { none { /* Nothing to do. */ } some(anonymous_module) { - #debug("(resolving block) found anonymous module, moving \ - down"); + debug!{"(resolving block) found anonymous module, moving \ + down"}; self.current_module = anonymous_module; } } @@ -3637,7 +3637,7 @@ class Resolver { self.current_module = orig_module; (*self.value_ribs).pop(); - #debug("(resolving block) leaving block"); + debug!{"(resolving block) leaving block"}; } fn resolve_type(ty: @ty, visitor: ResolveVisitor) { @@ -3652,8 +3652,8 @@ class Resolver { let mut result_def; alt self.resolve_path(path, TypeNS, true, visitor) { some(def) { - #debug("(resolving type) resolved `%s` to type", - *path.idents.last()); + debug!{"(resolving type) resolved `%s` to type", + *path.idents.last()}; result_def = some(def); } none { @@ -3690,17 +3690,17 @@ class Resolver { alt copy result_def { some(def) { // Write the result into the def map. - #debug("(resolving type) writing resolution for `%s` \ + debug!{"(resolving type) writing resolution for `%s` \ (id %d)", connect(path.idents.map(|x| *x), ~"::"), - path_id); + path_id}; self.record_def(path_id, def); } none { self.session.span_err - (ty.span, #fmt("use of undeclared type name `%s`", + (ty.span, fmt!{"use of undeclared type name `%s`", connect(path.idents.map(|x| *x), - ~"::"))); + ~"::")}); } } } @@ -3738,20 +3738,20 @@ class Resolver { alt self.resolve_enum_variant_or_const(atom) { FoundEnumVariant(def) if mode == RefutableMode { - #debug("(resolving pattern) resolving `%s` to \ + debug!{"(resolving pattern) resolving `%s` to \ enum variant", - *path.idents[0]); + *path.idents[0]}; self.record_def(pattern.id, def); } FoundEnumVariant(_) { self.session.span_err(pattern.span, - #fmt("declaration of `%s` \ + fmt!{"declaration of `%s` \ shadows an enum \ that's in scope", *(*self.atom_table). atom_to_str - (atom))); + (atom)}); } FoundConst { self.session.span_err(pattern.span, @@ -3760,8 +3760,8 @@ class Resolver { in scope"); } EnumVariantOrConstNotFound { - #debug("(resolving pattern) binding `%s`", - *path.idents[0]); + debug!{"(resolving pattern) binding `%s`", + *path.idents[0]}; let is_mutable = mutability == Mutable; @@ -3804,9 +3804,9 @@ class Resolver { // in the same disjunct, which is an // error self.session.span_err(pattern.span, - #fmt("Identifier %s is bound more \ + fmt!{"Identifier %s is bound more \ than once in the same pattern", - path_to_str(path))); + path_to_str(path)}); } // Not bound in the same pattern: do nothing } @@ -3833,9 +3833,9 @@ class Resolver { } some(_) { self.session.span_err(path.span, - #fmt("not an enum \ + fmt!{"not an enum \ variant: %s", - *path.idents.last())); + *path.idents.last()}); } none { self.session.span_err(path.span, @@ -3962,9 +3962,9 @@ class Resolver { -> NameDefinition { if xray == NoXray && !self.name_is_exported(containing_module, name) { - #debug("(resolving definition of name in module) name `%s` is \ + debug!{"(resolving definition of name in module) name `%s` is \ unexported", - *(*self.atom_table).atom_to_str(name)); + *(*self.atom_table).atom_to_str(name)}; ret NoNameDefinition; } @@ -4044,9 +4044,9 @@ class Resolver { Failed { self.session.span_err(path.span, - #fmt("use of undeclared module `%s`", + fmt!{"use of undeclared module `%s`", *(*self.atom_table).atoms_to_str - ((*module_path_atoms).get()))); + ((*module_path_atoms).get())}); ret none; } @@ -4067,11 +4067,11 @@ class Resolver { NoNameDefinition { // We failed to resolve the name. Report an error. self.session.span_err(path.span, - #fmt("unresolved name: %s::%s", + fmt!{"unresolved name: %s::%s", *(*self.atom_table).atoms_to_str ((*module_path_atoms).get()), *(*self.atom_table).atom_to_str - (name))); + (name)}); ret none; } ChildNameDefinition(def) | ImportNameDefinition(def) { @@ -4098,9 +4098,9 @@ class Resolver { Failed { self.session.span_err(path.span, - #fmt("use of undeclared module `::%s`", + fmt!{"use of undeclared module `::%s`", *(*self.atom_table).atoms_to_str - ((*module_path_atoms).get()))); + ((*module_path_atoms).get())}); ret none; } @@ -4121,11 +4121,11 @@ class Resolver { NoNameDefinition { // We failed to resolve the name. Report an error. self.session.span_err(path.span, - #fmt("unresolved name: %s::%s", + fmt!{"unresolved name: %s::%s", *(*self.atom_table).atoms_to_str ((*module_path_atoms).get()), *(*self.atom_table).atom_to_str - (name))); + (name)}); ret none; } ChildNameDefinition(def) | ImportNameDefinition(def) { @@ -4159,10 +4159,10 @@ class Resolver { alt copy search_result { some(dl_def(def)) { - #debug("(resolving path in local ribs) resolved `%s` to \ + debug!{"(resolving path in local ribs) resolved `%s` to \ local: %?", *(*self.atom_table).atom_to_str(name), - def); + def}; ret some(def); } some(dl_field) | some(dl_impl(_)) | none { @@ -4189,9 +4189,9 @@ class Resolver { bindings with no def for that namespace?!"; } some(def) { - #debug("(resolving item path in lexical scope) \ + debug!{"(resolving item path in lexical scope) \ resolved `%s` to item", - *(*self.atom_table).atom_to_str(name)); + *(*self.atom_table).atom_to_str(name)}; ret some(def); } } @@ -4228,15 +4228,15 @@ class Resolver { alt self.resolve_path(path, ValueNS, true, visitor) { some(def) { // Write the result into the def map. - #debug("(resolving expr) resolved `%s`", - connect(path.idents.map(|x| *x), ~"::")); + debug!{"(resolving expr) resolved `%s`", + connect(path.idents.map(|x| *x), ~"::")}; self.record_def(expr.id, def); } none { self.session.span_err(expr.span, - #fmt("unresolved name: %s", + fmt!{"unresolved name: %s", connect(path.idents.map(|x| *x), - ~"::"))); + ~"::")}); } } @@ -4280,11 +4280,11 @@ class Resolver { } _ { self.session.span_err(path.span, - #fmt("`%s` does not name a \ + fmt!{"`%s` does not name a \ structure", connect(path.idents.map (|x| *x), - ~"::"))); + ~"::")}); } } @@ -4450,11 +4450,11 @@ class Resolver { alt self.trait_info.find(trait_def_id) { some(trait_info) if trait_info.contains_key(name) { - #debug("(adding trait info if containing method) found trait \ + debug!{"(adding trait info if containing method) found trait \ %d:%d for method '%s'", trait_def_id.crate, trait_def_id.node, - *(*self.atom_table).atom_to_str(name)); + *(*self.atom_table).atom_to_str(name)}; (*found_traits).push(trait_def_id); } some(_) | none { @@ -4470,7 +4470,7 @@ class Resolver { } fn record_def(node_id: node_id, def: def) { - #debug("(recording def) recording %? for %?", def, node_id); + debug!{"(recording def) recording %? for %?", def, node_id}; self.def_map.insert(node_id, def); } @@ -4503,9 +4503,9 @@ class Resolver { } some(_) { // Bail out. - #debug("(checking for unused imports in module subtree) not \ + debug!{"(checking for unused imports in module subtree) not \ checking for unused imports for `%s`", - self.module_to_str(module)); + self.module_to_str(module)}; ret; } } @@ -4600,14 +4600,14 @@ class Resolver { } fn dump_module(module: @Module) { - #debug("Dump of module `%s`:", self.module_to_str(module)); + debug!{"Dump of module `%s`:", self.module_to_str(module)}; - #debug("Children:"); + debug!{"Children:"}; for module.children.each |name, _child| { - #debug("* %s", *(*self.atom_table).atom_to_str(name)); + debug!{"* %s", *(*self.atom_table).atom_to_str(name)}; } - #debug("Import resolutions:"); + debug!{"Import resolutions:"}; for module.import_resolutions.each |name, import_resolution| { let mut module_repr; alt (*import_resolution).target_for_namespace(ModuleNS) { @@ -4645,24 +4645,24 @@ class Resolver { } } - #debug("* %s:%s%s%s%s", + debug!{"* %s:%s%s%s%s", *(*self.atom_table).atom_to_str(name), - module_repr, value_repr, type_repr, impl_repr); + module_repr, value_repr, type_repr, impl_repr}; } } fn dump_impl_scopes(impl_scopes: ImplScopes) { - #debug("Dump of impl scopes:"); + debug!{"Dump of impl scopes:"}; let mut i = 0u; let mut impl_scopes = impl_scopes; loop { alt *impl_scopes { cons(impl_scope, rest_impl_scopes) { - #debug("Impl scope %u:", i); + debug!{"Impl scope %u:", i}; for (*impl_scope).each |implementation| { - #debug("Impl: %s", *implementation.ident); + debug!{"Impl: %s", *implementation.ident}; } i += 1u; diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index b624bc63bfe..2e5d5051a79 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -67,8 +67,8 @@ enum dest { 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)] } + 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" } } } @@ -100,7 +100,7 @@ trait get_insn_ctxt { impl ccx_icx of get_insn_ctxt for @crate_ctxt { fn insn_ctxt(s: ~str) -> icx_popper { - #debug("new insn_ctxt: %s", s); + debug!{"new insn_ctxt: %s", s}; if self.sess.count_llvm_insns() { vec::push(*self.stats.llvm_insn_ctxt, s); } @@ -496,7 +496,7 @@ fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info { 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)); + log(debug, fmt!{"+++ declare_tydesc %s %s", ty_to_str(ccx.tcx, t), name}); let gvar = str::as_c_str(name, |buf| { llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, buf) }); @@ -1091,60 +1091,60 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, alt ti.take_glue { some(_) { } none { - #debug("+++ lazily_emit_tydesc_glue TAKE %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + 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"); ti.take_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_take_glue, ~"take"); - #debug("--- lazily_emit_tydesc_glue TAKE %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + debug!{"--- lazily_emit_tydesc_glue TAKE %s", + ppaux::ty_to_str(ccx.tcx, ti.ty)}; } } } else if field == abi::tydesc_field_drop_glue { alt ti.drop_glue { some(_) { } none { - #debug("+++ lazily_emit_tydesc_glue DROP %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + 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"); ti.drop_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_drop_glue, ~"drop"); - #debug("--- lazily_emit_tydesc_glue DROP %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + debug!{"--- lazily_emit_tydesc_glue DROP %s", + ppaux::ty_to_str(ccx.tcx, ti.ty)}; } } } else if field == abi::tydesc_field_free_glue { alt ti.free_glue { some(_) { } none { - #debug("+++ lazily_emit_tydesc_glue FREE %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + 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"); ti.free_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_free_glue, ~"free"); - #debug("--- lazily_emit_tydesc_glue FREE %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + debug!{"--- lazily_emit_tydesc_glue FREE %s", + ppaux::ty_to_str(ccx.tcx, ti.ty)}; } } } else if field == abi::tydesc_field_visit_glue { alt ti.visit_glue { some(_) { } none { - #debug("+++ lazily_emit_tydesc_glue VISIT %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + 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"); ti.visit_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, ~"visit"); - #debug("--- lazily_emit_tydesc_glue VISIT %s", - ppaux::ty_to_str(ccx.tcx, ti.ty)); + debug!{"--- lazily_emit_tydesc_glue VISIT %s", + ppaux::ty_to_str(ccx.tcx, ti.ty)}; } } } @@ -1698,7 +1698,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)]; + debug!{"%s", expr_to_str(ex)}; let _icx = bcx.insn_ctxt(~"trans_assign_op"); let t = expr_ty(bcx, src); let lhs_res = trans_lval(bcx, dst); @@ -1708,8 +1708,8 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, alt bcx.ccx().maps.method_map.find(ex.id) { some(origin) { let bcx = lhs_res.bcx; - #debug["user-defined method callee_id: %s", - ast_map::node_id_to_str(bcx.tcx().items, ex.callee_id)]; + debug!{"user-defined method callee_id: %s", + ast_map::node_id_to_str(bcx.tcx().items, ex.callee_id)}; let fty = node_id_type(bcx, ex.callee_id); let dty = expr_ty(bcx, dst); @@ -1745,7 +1745,7 @@ fn root_value(bcx: block, val: ValueRef, ty: ty::t, if bcx.sess().trace() { trans_trace( bcx, none, - #fmt["preserving until end of scope %d", scope_id]); + fmt!{"preserving until end of scope %d", scope_id}); } let root_loc = alloca_zeroed(bcx, type_of(bcx.ccx(), ty)); @@ -1764,9 +1764,9 @@ fn autoderef(cx: block, e_id: ast::node_id, let ccx = cx.ccx(); let mut derefs = 0u; while derefs < max { - #debug["autoderef(e_id=%d, v1=%s, t1=%s, derefs=%u)", + debug!{"autoderef(e_id=%d, v1=%s, t1=%s, derefs=%u)", e_id, val_str(ccx.tn, v1), ppaux::ty_to_str(ccx.tcx, t1), - derefs]; + derefs}; // root the autoderef'd value, if necessary: derefs += 1u; @@ -2113,8 +2113,8 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, alt ccx.monomorphized.find(hash_id) { some(val) { - #debug["leaving monomorphic fn %s", - ty::item_path_str(ccx.tcx, fn_id)]; + debug!{"leaving monomorphic fn %s", + ty::item_path_str(ccx.tcx, fn_id)}; ret {val: val, must_cast: must_cast}; } none {} @@ -2124,9 +2124,9 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, let mut llitem_ty = tpt.ty; let map_node = session::expect(ccx.sess, ccx.tcx.items.find(fn_id.node), - || #fmt("While monomorphizing %?, couldn't find it in the item map \ + || fmt!{"While monomorphizing %?, couldn't find it in the item map \ (may have attempted to monomorphize an item defined in a different \ - crate?)", fn_id)); + crate?)", fn_id}); // Get the path so that we can create a symbol let (pt, name, span) = alt map_node { ast_map::node_item(i, pt) { (pt, i.ident, i.span) } @@ -2250,7 +2250,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, }; ccx.monomorphizing.insert(fn_id, depth); - #debug["leaving monomorphic fn %s", ty::item_path_str(ccx.tcx, fn_id)]; + debug!{"leaving monomorphic fn %s", ty::item_path_str(ccx.tcx, fn_id)}; {val: lldecl, must_cast: must_cast} } @@ -2260,8 +2260,8 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id) alt ccx.external.find(fn_id) { some(some(node_id)) { // Already inline - #debug["maybe_instantiate_inline(%s): already inline as node id %d", - ty::item_path_str(ccx.tcx, fn_id), node_id]; + debug!{"maybe_instantiate_inline(%s): already inline as node id %d", + ty::item_path_str(ccx.tcx, fn_id), node_id}; local_def(node_id) } some(none) { fn_id } // Not inlinable @@ -2448,8 +2448,8 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result { ret {val: slf, kind: lv_owned}; } _ { - cx.sess().unimpl(#fmt("unsupported def type in trans_local_def: %?", - def)); + cx.sess().unimpl(fmt!{"unsupported def type in trans_local_def: %?", + def}); } } } @@ -2534,7 +2534,7 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t, let ix = field_idx_strict(bcx.tcx(), sp, field, fields); - #debug("val = %s ix = %u", bcx.val_str(val), ix); + debug!{"val = %s ix = %u", bcx.val_str(val), ix}; /* self is a class with a dtor, which means we have to select out the object itself @@ -2586,8 +2586,8 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr, len = Sub(bcx, len, C_uint(bcx.ccx(), 1u)); } - #debug("trans_index: base %s", val_str(bcx.ccx().tn, base)); - #debug("trans_index: len %s", val_str(bcx.ccx().tn, len)); + debug!{"trans_index: base %s", val_str(bcx.ccx().tn, base)}; + debug!{"trans_index: len %s", val_str(bcx.ccx().tn, len)}; let bounds_check = ICmp(bcx, lib::llvm::IntUGE, scaled_ix, len); let bcx = do with_cond(bcx, bounds_check) |bcx| { @@ -2645,8 +2645,8 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { let lv = unrooted(cx, e); if !cx.sess().no_asm_comments() { - add_comment(cx, #fmt["preserving until end of scope %d", - scope_id]); + add_comment(cx, fmt!{"preserving until end of scope %d", + scope_id}); } let _icx = lv.bcx.insn_ctxt(~"root_value_lval"); @@ -2707,7 +2707,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { * wrong address space and thus be the wrong type. */ fn non_gc_box_cast(cx: block, val: ValueRef) -> ValueRef { - #debug("non_gc_box_cast"); + debug!{"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))); @@ -2856,7 +2856,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, &temp_cleanups: ~[ValueRef], ret_flag: option<ValueRef>, derefs: uint) -> result { - #debug("+++ trans_arg_expr on %s", expr_to_str(e)); + debug!{"+++ trans_arg_expr on %s", expr_to_str(e)}; let _icx = cx.insn_ctxt(~"trans_arg_expr"); let ccx = cx.ccx(); let e_ty = expr_ty(cx, e); @@ -2881,7 +2881,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, // auto-deref value as required (this only applies to method // call receivers) of method - #debug(" pre-deref value: %s", val_str(lv.bcx.ccx().tn, lv.val)); + debug!{" pre-deref value: %s", val_str(lv.bcx.ccx().tn, lv.val)}; let {lv, e_ty} = if derefs == 0u { {lv: lv, e_ty: e_ty} } else { @@ -2893,11 +2893,11 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, }; // borrow value (convert from @T to &T and so forth) - #debug(" pre-adaptation value: %s", val_str(lv.bcx.ccx().tn, lv.val)); + debug!{" pre-adaptation value: %s", val_str(lv.bcx.ccx().tn, lv.val)}; let {lv, ty: e_ty} = adapt_borrowed_value(lv, e, e_ty); let mut bcx = lv.bcx; let mut val = lv.val; - #debug(" adapted value: %s", val_str(bcx.ccx().tn, val)); + debug!{" adapted value: %s", val_str(bcx.ccx().tn, val)}; // finally, deal with the various modes let arg_mode = ty::resolved_mode(ccx.tcx, arg.mode); @@ -2949,11 +2949,11 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, } if !is_bot && arg.ty != e_ty || ty::type_has_params(arg.ty) { - #debug(" casting from %s", val_str(bcx.ccx().tn, val)); + debug!{" casting from %s", val_str(bcx.ccx().tn, val)}; val = PointerCast(bcx, val, lldestty); } - #debug("--- trans_arg_expr passing %s", val_str(bcx.ccx().tn, val)); + debug!{"--- trans_arg_expr passing %s", val_str(bcx.ccx().tn, val)}; ret rslt(bcx, val); } @@ -2994,9 +2994,9 @@ fn adapt_borrowed_value(lv: lval_result, let (base, len) = tvec::get_base_and_len(bcx, val, e_ty); let p = alloca(bcx, T_struct(~[T_ptr(llunit_ty), ccx.int_type])); - #debug("adapt_borrowed_value: adapting %s to %s", + debug!{"adapt_borrowed_value: adapting %s to %s", val_str(bcx.ccx().tn, val), - val_str(bcx.ccx().tn, p)); + val_str(bcx.ccx().tn, p)}; Store(bcx, base, GEPi(bcx, p, ~[0u, abi::slice_elt_base])); Store(bcx, len, GEPi(bcx, p, ~[0u, abi::slice_elt_len])); @@ -3013,8 +3013,8 @@ fn adapt_borrowed_value(lv: lval_result, _ { bcx.tcx().sess.span_bug( - e.span, #fmt["cannot borrow a value of type %s", - ppaux::ty_to_str(bcx.tcx(), e_ty)]); + e.span, fmt!{"cannot borrow a value of type %s", + ppaux::ty_to_str(bcx.tcx(), e_ty)}); } } } @@ -3566,9 +3566,9 @@ fn lval_result_to_result(lv: lval_result, ty: ty::t) -> result { fn add_root_cleanup(bcx: block, scope_id: ast::node_id, root_loc: ValueRef, ty: ty::t) { - #debug["add_root_cleanup(bcx=%s, scope_id=%d, root_loc=%s, ty=%s)", + debug!{"add_root_cleanup(bcx=%s, scope_id=%d, root_loc=%s, ty=%s)", bcx.to_str(), scope_id, val_str(bcx.ccx().tn, root_loc), - ppaux::ty_to_str(bcx.ccx().tcx, ty)]; + ppaux::ty_to_str(bcx.ccx().tcx, ty)}; let bcx_scope = find_bcx_for_scope(bcx, scope_id); add_clean_temp_mem(bcx_scope, root_loc, ty); @@ -3582,7 +3582,7 @@ fn add_root_cleanup(bcx: block, scope_id: ast::node_id, alt bcx_sid.parent { none { bcx.tcx().sess.bug( - #fmt["no enclosing scope with id %d", scope_id]); + fmt!{"no enclosing scope with id %d", scope_id}); } some(bcx_par) { bcx_par } } @@ -3607,16 +3607,16 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { ret alt bcx.ccx().maps.root_map.find({id:e.id, derefs:0u}) { none { unrooted(bcx, e, dest) } some(scope_id) { - #debug["expression %d found in root map with scope %d", - e.id, scope_id]; + debug!{"expression %d found in root map with scope %d", + e.id, scope_id}; let ty = expr_ty(bcx, e); let root_loc = alloca_zeroed(bcx, type_of(bcx.ccx(), ty)); let bcx = unrooted(bcx, e, save_in(root_loc)); if !bcx.sess().no_asm_comments() { - add_comment(bcx, #fmt["preserving until end of scope %d", - scope_id]); + add_comment(bcx, fmt!{"preserving until end of scope %d", + scope_id}); } let _icx = bcx.insn_ctxt(~"root_value_expr"); @@ -3668,9 +3668,9 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { ast::expr_fn_block(decl, body, cap_clause) { alt check ty::get(expr_ty(bcx, e)).struct { ty::ty_fn({proto, _}) { - #debug("translating fn_block %s with type %s", + debug!{"translating fn_block %s with type %s", expr_to_str(e), - ppaux::ty_to_str(tcx, expr_ty(bcx, e))); + ppaux::ty_to_str(tcx, expr_ty(bcx, e))}; ret closure::trans_expr_fn(bcx, proto, decl, body, e.id, cap_clause, none, dest); } @@ -3793,13 +3793,13 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { let ptr_ty = expr_ty(bcx, e); let ptr_ptr_val = alloc_ty(bcx, ptr_ty); - #debug["ptr_ty = %s", ppaux::ty_to_str(tcx, ptr_ty)]; - #debug["ptr_ptr_val = %s", val_str(ccx.tn, ptr_ptr_val)]; + debug!{"ptr_ty = %s", ppaux::ty_to_str(tcx, ptr_ty)}; + debug!{"ptr_ptr_val = %s", val_str(ccx.tn, ptr_ptr_val)}; let void_ty = ty::mk_nil_ptr(tcx); let llvoid_ty = type_of(ccx, void_ty); let voidval = PointerCast(bcx, ptr_ptr_val, T_ptr(llvoid_ty)); - #debug["voidval = %s", val_str(ccx.tn, voidval)]; + debug!{"voidval = %s", val_str(ccx.tn, voidval)}; let static_ti = get_tydesc(ccx, expr_ty(bcx, val)); lazily_emit_all_tydesc_glue(ccx, static_ti); @@ -3813,9 +3813,9 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { arg_vals(~[lltydesc]), save_in(voidval)); - #debug["dest = %s", dest_str(ccx, dest)]; + debug!{"dest = %s", dest_str(ccx, dest)}; let ptr_val = Load(bcx, ptr_ptr_val); - #debug["ptr_val = %s", val_str(ccx.tn, ptr_val)]; + debug!{"ptr_val = %s", val_str(ccx.tn, ptr_val)}; let bcx = trans_expr(bcx, val, save_in(ptr_val)); store_in_dest(bcx, ptr_val, dest) } @@ -3832,8 +3832,8 @@ fn lval_to_dps(bcx: block, e: @ast::expr, dest: dest) -> block { let ty = expr_ty(bcx, e); let lv = trans_lval(bcx, e); let last_use = (lv.kind == lv_owned && last_use_map.contains_key(e.id)); - #debug["is last use (%s) = %b, %d", expr_to_str(e), last_use, - lv.kind as int]; + debug!{"is last use (%s) = %b, %d", expr_to_str(e), last_use, + lv.kind as int}; lval_result_to_dps(lv, ty, last_use, dest) } @@ -4166,7 +4166,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"); - #debug["trans_stmt(%s)", stmt_to_str(s)]; + debug!{"trans_stmt(%s)", stmt_to_str(s)}; if !cx.sess().no_asm_comments() { add_span_comment(cx, s.span, stmt_to_str(s)); @@ -4303,12 +4303,12 @@ fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>, let mut cur = bcx, bcx = bcx; let is_lpad = leave == none; loop { - #debug["cleanup_and_leave: leaving %s", cur.to_str()]; + debug!{"cleanup_and_leave: leaving %s", cur.to_str()}; if bcx.sess().trace() { trans_trace( bcx, none, - #fmt["cleanup_and_leave(%s)", cur.to_str()]); + fmt!{"cleanup_and_leave(%s)", cur.to_str()}); } alt cur.kind { @@ -5076,8 +5076,8 @@ fn register_fn_fuller(ccx: @crate_ctxt, sp: span, path: path, let llfn: ValueRef = decl_fn(ccx.llmod, ps, cc, llfty); ccx.item_symbols.insert(node_id, ps); - #debug["register_fn_fuller created fn %s for item %d with path %s", - val_str(ccx.tn, llfn), node_id, ast_map::path_to_str(path)]; + debug!{"register_fn_fuller created fn %s for item %d with path %s", + val_str(ccx.tn, llfn), node_id, ast_map::path_to_str(path)}; let is_main = is_main_name(path) && !ccx.sess.building_library; if is_main { create_main_wrapper(ccx, sp, llfn, node_type); } @@ -5218,8 +5218,8 @@ fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id, mono_ty) } none { - ccx.sess.bug(#fmt("get_dtor_symbol: not monomorphizing and \ - couldn't find a symbol for dtor %?", path)); + ccx.sess.bug(fmt!{"get_dtor_symbol: not monomorphizing and \ + couldn't find a symbol for dtor %?", path}); } } } @@ -5436,7 +5436,7 @@ fn trap(bcx: block) { fn push_rtcall(ccx: @crate_ctxt, name: ~str, did: ast::def_id) { if ccx.rtcalls.contains_key(name) { - fail #fmt("multiple definitions for runtime call %s", name); + fail fmt!{"multiple definitions for runtime call %s", name}; } ccx.rtcalls.insert(name, did); } @@ -5506,7 +5506,7 @@ fn gather_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) { ~[~"exchange_free", ~"exchange_malloc", ~"fail", ~"free", ~"malloc"]; for vec::each(expected_rtcalls) |name| { if !ccx.rtcalls.contains_key(name) { - fail #fmt("no definition for runtime call %s", name); + fail fmt!{"no definition for runtime call %s", name}; } } } @@ -5777,25 +5777,25 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, write_metadata(ccx, crate); if ccx.sess.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", - ccx.stats.n_glues_created)); - io::println(#fmt("n_null_glues: %u", ccx.stats.n_null_glues)); - io::println(#fmt("n_real_glues: %u", ccx.stats.n_real_glues)); + io::println(fmt!{"n_static_tydescs: %u", + ccx.stats.n_static_tydescs}); + io::println(fmt!{"n_glues_created: %u", + ccx.stats.n_glues_created}); + io::println(fmt!{"n_null_glues: %u", ccx.stats.n_null_glues}); + io::println(fmt!{"n_real_glues: %u", ccx.stats.n_real_glues}); // FIXME (#2280): this temporary shouldn't be // necessary, but seems to be, for borrowing. let times = copy *ccx.stats.fn_times; for vec::each(times) |timing| { - io::println(#fmt("time: %s took %d ms", timing.ident, - timing.time)); + io::println(fmt!{"time: %s took %d ms", timing.ident, + timing.time}); } } if ccx.sess.count_llvm_insns() { for ccx.stats.llvm_insns.each |k, v| { - io::println(#fmt("%-7u %s", v, k)); + io::println(fmt!{"%-7u %s", v, k}); } } ret (llmod, link_meta); diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs index 4519be6bd33..5fa90ecece2 100644 --- a/src/rustc/middle/trans/build.rs +++ b/src/rustc/middle/trans/build.rs @@ -139,10 +139,10 @@ fn Invoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - #debug["Invoke(%s with arguments (%s))", + 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"); llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args), @@ -410,9 +410,9 @@ fn Load(cx: block, PointerVal: ValueRef) -> ValueRef { fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) { if cx.unreachable { ret; } - #debug["Store %s -> %s", + debug!{"Store %s -> %s", val_str(cx.ccx().tn, Val), - val_str(cx.ccx().tn, Ptr)]; + val_str(cx.ccx().tn, Ptr)}; count_insn(cx, ~"store"); llvm::LLVMBuildStore(B(cx), Val, Ptr); } @@ -670,9 +670,9 @@ fn Call(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef { unsafe { count_insn(cx, ~"call"); - #debug["Call(Fn=%s, Args=%?)", + debug!{"Call(Fn=%s, Args=%?)", val_str(cx.ccx().tn, Fn), - Args.map(|arg| val_str(cx.ccx().tn, arg))]; + Args.map(|arg| val_str(cx.ccx().tn, arg))}; ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs index 5cfc1d98ec6..c216b890ace 100644 --- a/src/rustc/middle/trans/closure.rs +++ b/src/rustc/middle/trans/closure.rs @@ -102,12 +102,12 @@ enum environment_value { 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)) } - env_move(v, t, lk) { #fmt("move(%s,%s)", val_str(ccx.tn, v), - ty_to_str(ccx.tcx, t)) } - env_ref(v, t, lk) { #fmt("ref(%s,%s)", val_str(ccx.tn, v), - ty_to_str(ccx.tcx, t)) } + env_copy(v, t, lk) { fmt!{"copy(%s,%s)", val_str(ccx.tn, v), + ty_to_str(ccx.tcx, t)} } + env_move(v, t, lk) { fmt!{"move(%s,%s)", val_str(ccx.tn, v), + ty_to_str(ccx.tcx, t)} } + env_ref(v, t, lk) { fmt!{"ref(%s,%s)", val_str(ccx.tn, v), + ty_to_str(ccx.tcx, t)} } } } @@ -131,7 +131,7 @@ fn mk_closure_tys(tcx: ty::ctxt, }); } let cdata_ty = ty::mk_tup(tcx, bound_tys); - #debug["cdata_ty=%s", ty_to_str(tcx, cdata_ty)]; + debug!{"cdata_ty=%s", ty_to_str(tcx, cdata_ty)}; ret cdata_ty; } @@ -201,16 +201,16 @@ fn store_environment(bcx: block, let cboxptr_ty = ty::mk_ptr(tcx, {ty:cbox_ty, mutbl:ast::m_imm}); let llbox = PointerCast(bcx, llbox, type_of(ccx, cboxptr_ty)); - #debug["tuplify_box_ty = %s", ty_to_str(tcx, cbox_ty)]; + debug!{"tuplify_box_ty = %s", ty_to_str(tcx, cbox_ty)}; // Copy expr values into boxed bindings. let mut bcx = bcx; do vec::iteri(bound_values) |i, bv| { - #debug["Copy %s into closure", ev_to_str(ccx, bv)]; + debug!{"Copy %s into closure", ev_to_str(ccx, bv)}; if !ccx.sess.no_asm_comments() { - add_comment(bcx, #fmt("Copy %s into closure", - ev_to_str(ccx, bv))); + add_comment(bcx, fmt!{"Copy %s into closure", + ev_to_str(ccx, bv)}); } let bound_data = GEPi(bcx, llbox, @@ -231,9 +231,9 @@ fn store_environment(bcx: block, bcx = move_val(bcx, INIT, bound_data, src, ty); } env_ref(val, ty, lv_owned) { - #debug["> storing %s into %s", + debug!{"> storing %s into %s", val_str(bcx.ccx().tn, val), - val_str(bcx.ccx().tn, bound_data)]; + val_str(bcx.ccx().tn, bound_data)}; Store(bcx, val, bound_data); } env_ref(val, ty, lv_owned_imm) { @@ -265,11 +265,11 @@ fn build_closure(bcx0: block, // Package up the captured upvars do vec::iter(cap_vars) |cap_var| { - #debug["Building closure: captured variable %?", cap_var]; + debug!{"Building closure: captured variable %?", cap_var}; let lv = trans_local_var(bcx, cap_var.def); let nid = ast_util::def_id_of_def(cap_var.def).node; - #debug["Node id is %s", - syntax::ast_map::node_id_to_str(bcx.ccx().tcx.items, nid)]; + debug!{"Node id is %s", + syntax::ast_map::node_id_to_str(bcx.ccx().tcx.items, nid)}; let mut ty = node_id_type(bcx, nid); alt cap_var.mode { capture::cap_ref { diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index b66fb82c9f8..bfb7676024a 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -248,9 +248,9 @@ fn cleanup_type(cx: ty::ctxt, ty: ty::t) -> cleantype { fn add_clean(cx: block, val: ValueRef, ty: ty::t) { if !ty::type_needs_drop(cx.tcx(), ty) { ret; } - #debug["add_clean(%s, %s, %s)", + debug!{"add_clean(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), - ty_to_str(cx.ccx().tcx, ty)]; + ty_to_str(cx.ccx().tcx, ty)}; let cleanup_type = cleanup_type(cx.tcx(), ty); do in_scope_cx(cx) |info| { vec::push(info.cleanups, clean(|a| base::drop_ty(a, val, ty), @@ -260,9 +260,9 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) { } fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) { if !ty::type_needs_drop(cx.tcx(), ty) { ret; } - #debug["add_clean_temp(%s, %s, %s)", + debug!{"add_clean_temp(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), - ty_to_str(cx.ccx().tcx, ty)]; + ty_to_str(cx.ccx().tcx, ty)}; let cleanup_type = cleanup_type(cx.tcx(), ty); fn do_drop(bcx: block, val: ValueRef, ty: ty::t) -> block { @@ -280,9 +280,9 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) { } fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) { if !ty::type_needs_drop(cx.tcx(), ty) { ret; } - #debug["add_clean_temp_mem(%s, %s, %s)", + debug!{"add_clean_temp_mem(%s, %s, %s)", cx.to_str(), val_str(cx.ccx().tn, val), - ty_to_str(cx.ccx().tcx, ty)]; + ty_to_str(cx.ccx().tcx, ty)}; let cleanup_type = cleanup_type(cx.tcx(), ty); do in_scope_cx(cx) |info| { vec::push(info.cleanups, @@ -459,8 +459,8 @@ fn in_scope_cx(cx: block, f: fn(scope_info)) { fn block_parent(cx: block) -> block { alt cx.parent { some(b) { b } - none { cx.sess().bug(#fmt("block_parent called on root block %?", - cx)); } + none { cx.sess().bug(fmt!{"block_parent called on root block %?", + cx}); } } } @@ -480,10 +480,10 @@ impl bcx_cxs for block { fn to_str() -> ~str { alt self.node_info { some(node_info) { - #fmt["[block %d]", node_info.id] + fmt!{"[block %d]", node_info.id} } none { - #fmt["[block %x]", ptr::addr_of(*self) as uint] + fmt!{"[block %x]", ptr::addr_of(*self) as uint} } } } @@ -997,8 +997,8 @@ fn field_idx_strict(cx: ty::ctxt, sp: span, ident: ast::ident, fields: ~[ty::field]) -> uint { alt ty::field_idx(ident, fields) { - none { cx.sess.span_bug(sp, #fmt("base expr doesn't appear to \ - have a field named %s", *ident)); } + none { cx.sess.span_bug(sp, fmt!{"base expr doesn't appear to \ + have a field named %s", *ident}); } some(i) { i } } } diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs index b18569a093b..3197dc00884 100644 --- a/src/rustc/middle/trans/debuginfo.rs +++ b/src/rustc/middle/trans/debuginfo.rs @@ -178,7 +178,7 @@ fn create_compile_unit(cx: @crate_ctxt) lli32(DW_LANG_RUST), llstr(crate_name), llstr(work_dir), - llstr(#env["CFG_VERSION"]), + llstr(env!{"CFG_VERSION"}), lli1(true), // deprecated: main compile unit lli1(cx.sess.opts.optimize != 0u), llstr(~""), // flags (???) @@ -734,7 +734,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { let cx = fcx.ccx; let dbg_cx = option::get(cx.dbg_cx); - #debug("~~"); + debug!{"~~"}; log(debug, fcx.id); let sp = option::get(fcx.span); diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 747549e78b8..5313cee2323 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -937,10 +937,10 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, ast_map::node_expr(e) { e.span } }; ccx.sess.span_fatal( - sp, #fmt("reinterpret_cast called on types \ + sp, fmt!{"reinterpret_cast called on types \ with different size: %s (%u) to %s (%u)", ty_to_str(ccx.tcx, tp_ty), tp_sz, - ty_to_str(ccx.tcx, substs.tys[1]), out_sz)); + ty_to_str(ccx.tcx, substs.tys[1]), out_sz}); } if !ty::type_is_nil(substs.tys[1]) { let cast = PointerCast(bcx, get_param(decl, first_real_arg), diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs index 0be970357e8..0250b17f6fe 100644 --- a/src/rustc/middle/trans/reachable.rs +++ b/src/rustc/middle/trans/reachable.rs @@ -177,8 +177,8 @@ fn traverse_inline_body(cx: ctx, body: blk) { some(d) { traverse_def_id(cx, def_id_of_def(d)); } - none { cx.tcx.sess.span_bug(e.span, #fmt("Unbound node \ - id %? while traversing %s", e.id, expr_to_str(e))); } + none { cx.tcx.sess.span_bug(e.span, fmt!{"Unbound node \ + id %? while traversing %s", e.id, expr_to_str(e)}); } } } expr_field(_, _, _) { diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs index 56444f1d281..82cb96f660d 100644 --- a/src/rustc/middle/trans/reflect.rs +++ b/src/rustc/middle/trans/reflect.rs @@ -62,15 +62,15 @@ impl methods for reflector { let get_lval = |bcx| { let callee = impl::trans_trait_callee(bcx, v, mth_ty, mth_idx); - #debug("calling mth ty %s, lltype %s", + debug!{"calling mth ty %s, lltype %s", ty_to_str(bcx.ccx().tcx, mth_ty), - val_str(bcx.ccx().tn, callee.val)); + val_str(bcx.ccx().tn, callee.val)}; callee }; - #debug("passing %u args:", vec::len(args)); + debug!{"passing %u args:", vec::len(args)}; let bcx = self.bcx; for args.eachi |i, a| { - #debug("arg %u: %s", i, val_str(bcx.ccx().tn, a)); + debug!{"arg %u: %s", i, val_str(bcx.ccx().tn, a)}; } let d = empty_dest_cell(); let bcx = @@ -111,8 +111,8 @@ impl methods for reflector { fn visit_ty(t: ty::t) { let bcx = self.bcx; - #debug("reflect::visit_ty %s", - ty_to_str(bcx.ccx().tcx, t)); + debug!{"reflect::visit_ty %s", + ty_to_str(bcx.ccx().tcx, t)}; alt ty::get(t).struct { ty::ty_bot { self.leaf(~"bot") } diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs index bc698e6e3d2..bfd2f18bac9 100644 --- a/src/rustc/middle/trans/tvec.rs +++ b/src/rustc/middle/trans/tvec.rs @@ -189,9 +189,9 @@ fn trans_evec(bcx: block, args: ~[@ast::expr], // Store the individual elements. let mut i = 0u, temp_cleanups = ~[val]; - #debug("trans_evec: v: %s, dataptr: %s", + debug!{"trans_evec: v: %s, dataptr: %s", val_str(ccx.tn, val), - val_str(ccx.tn, dataptr)); + val_str(ccx.tn, dataptr)}; for vec::each(args) |e| { let lleltptr = InBoundsGEP(bcx, dataptr, ~[C_uint(ccx, i)]); bcx = base::trans_expr_save_in(bcx, e, lleltptr); @@ -259,7 +259,7 @@ fn get_base_and_len(cx: block, v: ValueRef, e_ty: ty::t) (base, len) } ty::vstore_uniq | ty::vstore_box { - #debug["get_base_and_len: %s", val_str(ccx.tn, v)]; + debug!{"get_base_and_len: %s", val_str(ccx.tn, v)}; let body = tvec::get_bodyptr(cx, v); (tvec::get_dataptr(cx, body), tvec::get_fill(cx, body)) } @@ -276,13 +276,13 @@ fn trans_estr(bcx: block, s: @~str, vstore: ast::vstore, ast::vstore_fixed(_) { // "hello"/_ => "hello"/5 => ~[i8 x 6] in llvm - #debug("trans_estr: fixed: %s", *s); + debug!{"trans_estr: fixed: %s", *s}; C_postr(*s) } ast::vstore_slice(_) { // "hello" => (*i8, 6u) in llvm - #debug("trans_estr: slice '%s'", *s); + debug!{"trans_estr: slice '%s'", *s}; C_estr_slice(ccx, *s) } @@ -303,7 +303,7 @@ fn trans_estr(bcx: block, s: @~str, vstore: ast::vstore, } }; - #debug("trans_estr: type: %s", val_str(ccx.tn, c)); + debug!{"trans_estr: type: %s", val_str(ccx.tn, c)}; base::store_in_dest(bcx, c, dest) } diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs index ab3384dad25..d06bf94f5e1 100644 --- a/src/rustc/middle/trans/type_of.rs +++ b/src/rustc/middle/trans/type_of.rs @@ -66,7 +66,7 @@ fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef { } fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { - #debug("type_of %?: %?", t, ty::get(t)); + debug!{"type_of %?: %?", t, ty::get(t)}; // Check the cache. if cx.lltypes.contains_key(t) { ret cx.lltypes.get(t); } @@ -197,7 +197,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t) -> TypeRef { - #debug("type_of_enum %?: %?", t, ty::get(t)); + debug!{"type_of_enum %?: %?", t, ty::get(t)}; // Every enum type has a unique name. When we find our roots // for GC and unwinding we will use this name to rediscover @@ -233,7 +233,7 @@ fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str { (~"class", did, substs.tps) } }; - ret #fmt( + ret fmt!{ "%s %s[#%d]", name, util::ppaux::parameterized( @@ -242,7 +242,7 @@ fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str { none, tps), did.crate - ); + }; } fn type_of_dtor(ccx: @crate_ctxt, self_ty: ty::t) -> TypeRef { diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index e7167eee91a..6bb19724afe 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -61,8 +61,8 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) } let map_node = alt ccx.tcx.items.find(fn_id_loc.node) { some(x) { x } - none { ccx.sess.bug(#fmt("type_uses_for: unbound item ID %?", - fn_id_loc)); } + none { ccx.sess.bug(fmt!{"type_uses_for: unbound item ID %?", + fn_id_loc}); } }; alt check map_node { ast_map::node_item(@{node: item_fn(_, _, body), _}, _) | diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs index b1d7762ec7b..27379552a8c 100644 --- a/src/rustc/middle/trans/uniq.rs +++ b/src/rustc/middle/trans/uniq.rs @@ -40,8 +40,8 @@ fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result { let src_box = v; let src_body = opaque_box_body(bcx, content_ty, src_box); let src_body = load_if_immediate(bcx, src_body, content_ty); - #debug("ST: %?", val_str(bcx.ccx().tn, src_body)); - #debug("DT: %?", val_str(bcx.ccx().tn, dst_body)); + debug!{"ST: %?", val_str(bcx.ccx().tn, src_body)}; + debug!{"DT: %?", val_str(bcx.ccx().tn, dst_body)}; let bcx = copy_val(bcx, INIT, dst_body, src_body, content_ty); let src_tydesc_ptr = GEPi(bcx, src_box, diff --git a/src/rustc/middle/tstate/annotate.rs b/src/rustc/middle/tstate/annotate.rs index de9a4540d21..f4b2e5e6442 100644 --- a/src/rustc/middle/tstate/annotate.rs +++ b/src/rustc/middle/tstate/annotate.rs @@ -16,8 +16,8 @@ fn collect_ids_block(b: blk, rs: @mut ~[node_id]) { fn collect_ids_stmt(s: @stmt, rs: @mut ~[node_id]) { alt s.node { stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) { - #debug["node_id %s", int::str(id)]; - #debug["%s", stmt_to_str(*s)]; + debug!{"node_id %s", int::str(id)}; + debug!{"%s", stmt_to_str(*s)}; vec::push(*rs, id); } } diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs index 1e6bcd52ede..0f8185a0ee9 100644 --- a/src/rustc/middle/tstate/auxiliary.rs +++ b/src/rustc/middle/tstate/auxiliary.rs @@ -49,10 +49,10 @@ fn comma_str(args: ~[@constr_arg_use]) -> ~str { } fn constraint_to_str(tcx: ty::ctxt, c: sp_constr) -> ~str { - ret #fmt("%s(%s) - arising from %s", + 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)); + codemap::span_to_str(c.span, tcx.sess.codemap)}; } fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> ~str { @@ -110,36 +110,36 @@ fn log_cond_err(v: ~[uint]) { log(error, tos(v)); } fn log_pp(pp: pre_and_post) { let p1 = pp.precondition.to_vec(); let p2 = pp.postcondition.to_vec(); - #debug("pre:"); + debug!{"pre:"}; log_cond(p1); - #debug("post:"); + debug!{"post:"}; log_cond(p2); } fn log_pp_err(pp: pre_and_post) { let p1 = pp.precondition.to_vec(); let p2 = pp.postcondition.to_vec(); - #error("pre:"); + error!{"pre:"}; log_cond_err(p1); - #error("post:"); + error!{"post:"}; log_cond_err(p2); } fn log_states(pp: pre_and_post_state) { let p1 = pp.prestate.to_vec(); let p2 = pp.poststate.to_vec(); - #debug("prestate:"); + debug!{"prestate:"}; log_cond(p1); - #debug("poststate:"); + debug!{"poststate:"}; log_cond(p2); } fn log_states_err(pp: pre_and_post_state) { let p1 = pp.prestate.to_vec(); let p2 = pp.poststate.to_vec(); - #error("prestate:"); + error!{"prestate:"}; log_cond_err(p1); - #error("poststate:"); + error!{"poststate:"}; log_cond_err(p2); } @@ -263,7 +263,7 @@ fn get_ts_ann(ccx: crate_ctxt, i: node_id) -> option<ts_ann> { fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { alt get_ts_ann(ccx, id) { none { - #error("node_id_to_ts_ann: no ts_ann for node_id %d", id); + error!{"node_id_to_ts_ann: no ts_ann for node_id %d", id}; fail; } some(tt) { ret tt; } @@ -271,12 +271,12 @@ fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { } fn node_id_to_poststate(ccx: crate_ctxt, id: node_id) -> poststate { - #debug("node_id_to_poststate"); + debug!{"node_id_to_poststate"}; ret node_id_to_ts_ann(ccx, id).states.poststate; } fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { - #debug("stmt_to_ann"); + debug!{"stmt_to_ann"}; alt s.node { stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) { ret node_id_to_ts_ann(ccx, id); @@ -287,14 +287,14 @@ fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { /* fails if e has no annotation */ fn expr_states(ccx: crate_ctxt, e: @expr) -> pre_and_post_state { - #debug("expr_states"); + debug!{"expr_states"}; ret node_id_to_ts_ann(ccx, e.id).states; } /* fails if e has no annotation */ fn expr_pp(ccx: crate_ctxt, e: @expr) -> pre_and_post { - #debug("expr_pp"); + debug!{"expr_pp"}; ret node_id_to_ts_ann(ccx, e.id).conditions; } @@ -305,7 +305,7 @@ fn stmt_pp(ccx: crate_ctxt, s: stmt) -> pre_and_post { /* fails if b has no annotation */ fn block_pp(ccx: crate_ctxt, b: blk) -> pre_and_post { - #debug("block_pp"); + debug!{"block_pp"}; ret node_id_to_ts_ann(ccx, b.node.id).conditions; } @@ -320,7 +320,7 @@ fn clear_precond(ccx: crate_ctxt, id: node_id) { } fn block_states(ccx: crate_ctxt, b: blk) -> pre_and_post_state { - #debug("block_states"); + debug!{"block_states"}; ret node_id_to_ts_ann(ccx, b.node.id).states; } @@ -381,43 +381,43 @@ fn block_poststate(ccx: crate_ctxt, b: blk) -> poststate { } fn set_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { - #debug("set_prestate_ann"); + debug!{"set_prestate_ann"}; ret set_prestate(node_id_to_ts_ann(ccx, id), pre); } fn extend_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { - #debug("extend_prestate_ann"); + debug!{"extend_prestate_ann"}; ret extend_prestate(node_id_to_ts_ann(ccx, id).states.prestate, pre); } fn set_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { - #debug("set_poststate_ann"); + debug!{"set_poststate_ann"}; ret set_poststate(node_id_to_ts_ann(ccx, id), post); } fn extend_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { - #debug("extend_poststate_ann"); + debug!{"extend_poststate_ann"}; ret extend_poststate(node_id_to_ts_ann(ccx, id).states.poststate, post); } fn set_pre_and_post(ccx: crate_ctxt, id: node_id, pre: precond, post: postcond) { - #debug("set_pre_and_post"); + debug!{"set_pre_and_post"}; let tt = node_id_to_ts_ann(ccx, id); set_precondition(tt, pre); set_postcondition(tt, post); } fn copy_pre_post(ccx: crate_ctxt, id: node_id, sub: @expr) { - #debug("set_pre_and_post"); + debug!{"set_pre_and_post"}; let p = expr_pp(ccx, sub); copy_pre_post_(ccx, id, p.precondition, p.postcondition); } fn copy_pre_post_(ccx: crate_ctxt, id: node_id, pre: prestate, post: poststate) { - #debug("set_pre_and_post"); + debug!{"set_pre_and_post"}; let tt = node_id_to_ts_ann(ccx, id); set_precondition(tt, pre); set_postcondition(tt, post); @@ -460,7 +460,7 @@ fn constraints_expr(cx: ty::ctxt, e: @expr) -> ~[@ty::constr] { fn node_id_to_def_strict(cx: ty::ctxt, id: node_id) -> def { alt cx.def_map.find(id) { none { - #error("node_id_to_def: node_id %d has no def", id); + error!{"node_id_to_def: node_id %d has no def", id}; fail; } some(d) { ret d; } @@ -498,8 +498,8 @@ fn constraints(fcx: fn_ctxt) -> ~[norm_constraint] { // should freeze it at some earlier point. 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)); + debug!{"match_args: looking at %s", + 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)); @@ -530,8 +530,8 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use { } some(what) { tcx.sess.span_bug(e.span, - #fmt("exprs_to_constr_args: non-local variable %? \ - as pred arg", what)); + fmt!{"exprs_to_constr_args: non-local variable %? \ + as pred arg", what}); } none { tcx.sess.span_bug(e.span, @@ -824,9 +824,9 @@ fn forget_in_postcond(fcx: fn_ctxt, parent_exp: node_id, dead_v: node_id) { let d = local_node_id_to_local_def_id(fcx, dead_v); do option::iter(d) |d_id| { do for_constraints_mentioning(fcx, d_id) |c| { - #debug("clearing constraint %u %s", + debug!{"clearing constraint %u %s", c.bit_num, - constraint_to_str(fcx.ccx.tcx, c.c)); + constraint_to_str(fcx.ccx.tcx, c.c)}; clear_in_postcond(c.bit_num, node_id_to_ts_ann(fcx.ccx, parent_exp).conditions); diff --git a/src/rustc/middle/tstate/ck.rs b/src/rustc/middle/tstate/ck.rs index d534b764c07..f1dc6a566af 100644 --- a/src/rustc/middle/tstate/ck.rs +++ b/src/rustc/middle/tstate/ck.rs @@ -46,11 +46,11 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) { let prec: precond = ann_precond(a); let pres: prestate = ann_prestate(a); - #debug("check_states_stmt:"); + debug!{"check_states_stmt:"}; log(debug, print::pprust::stmt_to_str(*s)); - #debug("prec = "); + debug!{"prec = "}; log_tritv(fcx, prec); - #debug("pres = "); + debug!{"pres = "}; log_tritv(fcx, pres); if !implies(pres, prec) { diff --git a/src/rustc/middle/tstate/collect_locals.rs b/src/rustc/middle/tstate/collect_locals.rs index d7bfd031307..448b7a5231f 100644 --- a/src/rustc/middle/tstate/collect_locals.rs +++ b/src/rustc/middle/tstate/collect_locals.rs @@ -87,15 +87,15 @@ fn contains_constrained_calls(tcx: ty::ctxt, body: blk) -> bool { fn visit_expr(e: @expr, &&cx: cx, v: visit::vt<cx>) { import syntax::print::pprust; - #debug("visiting %?", pprust::expr_to_str(e)); + debug!{"visiting %?", pprust::expr_to_str(e)}; visit::visit_expr(e, cx, v); if constraints_expr(cx.tcx, e).is_not_empty() { - #debug("has constraints"); + debug!{"has constraints"}; cx.has = true; } else { - #debug("has not constraints"); + debug!{"has not constraints"}; } } } @@ -140,7 +140,7 @@ fn mk_fn_info(ccx: crate_ctxt, used_vars: v, ignore: ignore}; ccx.fm.insert(id, rslt); - #debug("%s has %u constraints", *name, num_constraints(rslt)); + debug!{"%s has %u constraints", *name, num_constraints(rslt)}; } diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs index 36b7d9c7308..08f0736c1da 100644 --- a/src/rustc/middle/tstate/pre_post_conditions.rs +++ b/src/rustc/middle/tstate/pre_post_conditions.rs @@ -16,12 +16,12 @@ import driver::session::session; import std::map::hashmap; fn find_pre_post_mod(_m: _mod) -> _mod { - #debug("implement find_pre_post_mod!"); + debug!{"implement find_pre_post_mod!"}; fail; } fn find_pre_post_foreign_mod(_m: foreign_mod) -> foreign_mod { - #debug("implement find_pre_post_foreign_mod"); + debug!{"implement find_pre_post_foreign_mod"}; fail; } @@ -66,7 +66,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) { be the union of all postconditions for <args> */ fn find_pre_post_exprs(fcx: fn_ctxt, args: ~[@expr], id: node_id) { if vec::len::<@expr>(args) > 0u { - #debug["find_pre_post_exprs: oper = %s", expr_to_str(args[0])]; + debug!{"find_pre_post_exprs: oper = %s", expr_to_str(args[0])}; } fn do_one(fcx: fn_ctxt, e: @expr) { find_pre_post_expr(fcx, e); } for args.each |e| { do_one(fcx, e); } @@ -452,7 +452,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { } fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) { - #debug["stmt = %s", stmt_to_str(s)]; + debug!{"stmt = %s", stmt_to_str(s)}; alt s.node { stmt_decl(adecl, id) { alt adecl.node { diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs index e427841103f..9c4285774f7 100644 --- a/src/rustc/middle/tstate/states.rs +++ b/src/rustc/middle/tstate/states.rs @@ -174,9 +174,9 @@ fn find_pre_post_state_call(fcx: fn_ctxt, pres: prestate, a: @expr, // bug) if vec::len(bs) != vec::len(ops) { fcx.ccx.tcx.sess.span_bug(a.span, - #fmt["mismatched arg lengths: \ + fmt!{"mismatched arg lengths: \ %u exprs vs. %u ops", - vec::len(bs), vec::len(ops)]); + vec::len(bs), vec::len(ops)}); } ret find_pre_post_state_exprs(fcx, pres, id, ops, bs, cf) || changed; @@ -299,7 +299,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { return_val); } expr_call(operator, operands, _) { - #debug["hey it's a call: %s", expr_to_str(e)]; + debug!{"hey it's a call: %s", expr_to_str(e)}; ret find_pre_post_state_call(fcx, pres, operator, e.id, callee_arg_init_ops(fcx, operator.id), operands, @@ -505,10 +505,10 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { let stmt_ann = stmt_to_ann(fcx.ccx, *s); - #debug["[ %s ]", *fcx.name]; - #debug["*At beginning: stmt = %s", stmt_to_str(*s)]; - #debug["*prestate = %s", stmt_ann.states.prestate.to_str()]; - #debug["*poststate = %s", stmt_ann.states.prestate.to_str()]; + debug!{"[ %s ]", *fcx.name}; + debug!{"*At beginning: stmt = %s", stmt_to_str(*s)}; + debug!{"*prestate = %s", stmt_ann.states.prestate.to_str()}; + debug!{"*poststate = %s", stmt_ann.states.prestate.to_str()}; alt s.node { stmt_decl(adecl, id) { @@ -524,10 +524,10 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { let mut changed = set_poststate(stmt_ann, c_and_p.post) | c_and_p.changed; - #debug["Summary: stmt = %s", stmt_to_str(*s)]; - #debug["prestate = %s", stmt_ann.states.prestate.to_str()]; - #debug["poststate = %s", stmt_ann.states.poststate.to_str()]; - #debug["changed = %s", bool::to_str(changed)]; + debug!{"Summary: stmt = %s", stmt_to_str(*s)}; + debug!{"prestate = %s", stmt_ann.states.prestate.to_str()}; + debug!{"poststate = %s", stmt_ann.states.poststate.to_str()}; + debug!{"changed = %s", bool::to_str(changed)}; ret changed; } @@ -544,10 +544,10 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { set_poststate(stmt_ann, expr_poststate(fcx.ccx, ex)); - #debug["Finally: %s", stmt_to_str(*s)]; - #debug["prestate = %s", stmt_ann.states.prestate.to_str()]; - #debug["poststate = %s", stmt_ann.states.poststate.to_str()]; - #debug["changed = %s", bool::to_str(changed)]; + debug!{"Finally: %s", stmt_to_str(*s)}; + debug!{"prestate = %s", stmt_ann.states.prestate.to_str()}; + debug!{"poststate = %s", stmt_ann.states.poststate.to_str()}; + debug!{"changed = %s", bool::to_str(changed)}; ret changed; } @@ -602,7 +602,7 @@ fn find_pre_post_state_fn(fcx: fn_ctxt, let mut changed = find_pre_post_state_block(fcx, block_pre, f_body); /* - #error("find_pre_post_state_fn"); + error!{"find_pre_post_state_fn"}; log(error, changed); fcx.ccx.tcx.sess.span_note(f_body.span, fcx.name); */ diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index a2ba9277fd0..cb055055091 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -483,17 +483,17 @@ iface vid { 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()} } } trait purity_to_str { @@ -1050,23 +1050,23 @@ fn substs_is_noop(substs: substs) -> bool { } fn substs_to_str(cx: ctxt, substs: substs) -> ~str { - #fmt["substs(self_r=%s, self_ty=%s, tps=%?)", + 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.tps.map(|t| ty_to_str(cx, t))] + substs.tps.map(|t| ty_to_str(cx, t))} } fn subst(cx: ctxt, substs: substs, typ: t) -> t { - #debug["subst(substs=%s, typ=%s)", + debug!{"subst(substs=%s, typ=%s)", substs_to_str(cx, substs), - ty_to_str(cx, typ)]; + ty_to_str(cx, typ)}; if substs_is_noop(substs) { ret typ; } let r = do_subst(cx, substs, typ); - #debug[" r = %s", ty_to_str(cx, r)]; + debug!{" r = %s", ty_to_str(cx, r)}; ret r; fn do_subst(cx: ctxt, @@ -1799,27 +1799,27 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { fn type_requires(cx: ctxt, seen: @mut ~[def_id], r_ty: t, ty: t) -> bool { - #debug["type_requires(%s, %s)?", + debug!{"type_requires(%s, %s)?", ty_to_str(cx, r_ty), - ty_to_str(cx, ty)]; + ty_to_str(cx, ty)}; let r = { get(r_ty).struct == get(ty).struct || subtypes_require(cx, seen, r_ty, ty) }; - #debug["type_requires(%s, %s)? %b", + debug!{"type_requires(%s, %s)? %b", ty_to_str(cx, r_ty), ty_to_str(cx, ty), - r]; + r}; ret r; } fn subtypes_require(cx: ctxt, seen: @mut ~[def_id], r_ty: t, ty: t) -> bool { - #debug["subtypes_require(%s, %s)?", + debug!{"subtypes_require(%s, %s)?", ty_to_str(cx, r_ty), - ty_to_str(cx, ty)]; + ty_to_str(cx, ty)}; let r = alt get(ty).struct { ty_nil | @@ -1895,10 +1895,10 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { } }; - #debug["subtypes_require(%s, %s)? %b", + debug!{"subtypes_require(%s, %s)? %b", ty_to_str(cx, r_ty), ty_to_str(cx, ty), - r]; + r}; ret r; } @@ -1910,7 +1910,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) -> bool { let sty = get(ty).struct; - #debug("type_structurally_contains: %s", ty_to_str(cx, ty)); + debug!{"type_structurally_contains: %s", ty_to_str(cx, ty)}; if test(sty) { ret true; } alt sty { ty_enum(did, substs) { @@ -2232,8 +2232,8 @@ fn hash_type_structure(st: sty) -> uint { fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t { alt smallintmap::find(*cx.node_types, id as uint) { some(t) { t } - none { cx.sess.bug(#fmt("node_id_to_type: unbound node ID %s", - ast_map::node_id_to_str(cx.items, id))); } + none { cx.sess.bug(fmt!{"node_id_to_type: unbound node ID %s", + ast_map::node_id_to_str(cx.items, id)}); } } } @@ -2298,15 +2298,15 @@ fn is_pred_ty(fty: t) -> bool { fn ty_var_id(typ: t) -> tv_vid { alt get(typ).struct { ty_var(vid) { ret vid; } - _ { #error("ty_var_id called on non-var ty"); fail; } + _ { error!{"ty_var_id called on non-var ty"}; fail; } } } fn ty_var_integral_id(typ: t) -> tvi_vid { alt get(typ).struct { ty_var_integral(vid) { ret vid; } - _ { #error("ty_var_integral_id called on ty other than \ - ty_var_integral"); + _ { error!{"ty_var_integral_id called on ty other than \ + ty_var_integral"}; fail; } } } @@ -2462,7 +2462,7 @@ fn canon_mode(cx: ctxt, m0: ast::mode) -> ast::mode { fn resolved_mode(cx: ctxt, m: ast::mode) -> ast::rmode { alt canon_mode(cx, m) { ast::infer(_) { - cx.sess.bug(#fmt["mode %? was never resolved", m]); + cx.sess.bug(fmt!{"mode %? was never resolved", m}); } ast::expl(m0) { m0 } } @@ -2510,7 +2510,7 @@ fn ty_sort_str(cx: ctxt, t: t) -> ~str { ty_to_str(cx, t) } - ty_enum(id, _) { #fmt["enum %s", item_path_str(cx, id)] } + ty_enum(id, _) { fmt!{"enum %s", item_path_str(cx, id)} } ty_box(_) { ~"@-ptr" } ty_uniq(_) { ~"~-ptr" } ty_evec(_, _) { ~"vector" } @@ -2519,8 +2519,8 @@ fn ty_sort_str(cx: ctxt, t: t) -> ~str { 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_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" } @@ -2547,12 +2547,12 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> ~str { ~" function was expected"; } terr_purity_mismatch(f1, f2) { - ret #fmt["expected %s fn but found %s fn", - purity_to_str(f1), purity_to_str(f2)]; + ret fmt!{"expected %s fn but found %s fn", + purity_to_str(f1), purity_to_str(f2)}; } terr_proto_mismatch(e, a) { - ret #fmt["closure protocol mismatch (%s vs %s)", - proto_to_str(e), proto_to_str(a)]; + 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"; } @@ -2585,22 +2585,22 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> ~str { ~" but found " + mode_to_str(a_mode); } terr_regions_differ(subregion, superregion) { - ret #fmt("references with lifetime %s do not necessarily \ + ret fmt!{"references with lifetime %s do not necessarily \ outlive references with lifetime %s", region_to_str(cx, subregion), - region_to_str(cx, superregion)); + region_to_str(cx, superregion)}; } terr_vstores_differ(k, e_vs, a_vs) { - ret #fmt("%s storage differs: expected %s but found %s", + ret fmt!{"%s storage differs: expected %s but found %s", terr_vstore_kind_to_str(k), vstore_to_str(cx, e_vs), - vstore_to_str(cx, a_vs)); + vstore_to_str(cx, a_vs)}; } terr_in_field(err, fname) { - ret #fmt("in field `%s`, %s", *fname, type_err_to_str(cx, *err)); + ret fmt!{"in field `%s`, %s", *fname, type_err_to_str(cx, *err)}; } terr_sorts(exp, act) { - ret #fmt("%s vs %s", ty_sort_str(cx, exp), ty_sort_str(cx, act)); + 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 @@ -2638,7 +2638,7 @@ fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] { fn impl_traits(cx: ctxt, id: ast::def_id) -> ~[t] { if id.crate == ast::local_crate { - #debug("(impl_traits) searching for trait impl %?", id); + debug!{"(impl_traits) searching for trait impl %?", id}; alt cx.items.find(id.node) { some(ast_map::node_item(@{ node: ast::item_impl(_, trait_refs, _, _), @@ -2654,12 +2654,12 @@ fn impl_traits(cx: ctxt, id: ast::def_id) -> ~[t] { alt cx.def_map.find(id.node) { some(def_ty(trait_id)) { // XXX: Doesn't work cross-crate. - #debug("(impl_traits) found trait id %?", trait_id); + debug!{"(impl_traits) found trait id %?", trait_id}; ~[node_id_to_type(cx, trait_id.node)] } some(x) { - cx.sess.bug(#fmt("impl_traits: trait ref is in trait map \ - but is bound to %?", x)); + cx.sess.bug(fmt!{"impl_traits: trait ref is in trait map \ + but is bound to %?", x}); } none { ~[] @@ -2765,7 +2765,7 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { ast_map::node_expr(_) | ast_map::node_arg(_, _) | ast_map::node_local(_) | ast_map::node_export(_, _) | ast_map::node_block(_) { - cx.sess.bug(#fmt["cannot find item_path for node %?", node]); + cx.sess.bug(fmt!{"cannot find item_path for node %?", node}); } } } @@ -2899,8 +2899,8 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] { } } _ { - cx.sess.bug(#fmt("class ID not bound to an item: %s", - ast_map::node_id_to_str(cx.items, did.node))); + cx.sess.bug(fmt!{"class ID not bound to an item: %s", + ast_map::node_id_to_str(cx.items, did.node)}); } } } @@ -2962,8 +2962,8 @@ fn lookup_class_method_by_name(cx:ctxt, did: ast::def_id, name: ident, ret ast_util::local_def(m.id); } } - cx.sess.span_fatal(sp, #fmt("Class doesn't have a method \ - named %s", *name)); + cx.sess.span_fatal(sp, fmt!{"Class doesn't have a method \ + named %s", *name}); } else { csearch::get_class_method(cx.sess.cstore, did, name) diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs index f12bec35cfc..2338aa6368c 100644 --- a/src/rustc/middle/typeck.rs +++ b/src/rustc/middle/typeck.rs @@ -167,7 +167,7 @@ enum crate_ctxt { // Functions that write types into the node type table fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) { - #debug["write_ty_to_tcx(%d, %s)", node_id, ty_to_str(tcx, ty)]; + debug!{"write_ty_to_tcx(%d, %s)", node_id, ty_to_str(tcx, ty)}; smallintmap::insert(*tcx.node_types, node_id as uint, ty); } fn write_substs_to_tcx(tcx: ty::ctxt, @@ -266,10 +266,10 @@ fn check_main_fn_ty(ccx: @crate_ctxt, arg_is_argv_ty(tcx, inputs[0]); if !ok { tcx.sess.span_err(main_span, - #fmt("Wrong type in main function: found `%s`, \ + fmt!{"Wrong type in main function: found `%s`, \ expected `extern fn(~[str]) -> ()` \ or `extern fn() -> ()`", - ty_to_str(tcx, main_t))); + ty_to_str(tcx, main_t)}); } } _ { diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs index 3baea12ab48..341d9460c4b 100644 --- a/src/rustc/middle/typeck/astconv.rs +++ b/src/rustc/middle/typeck/astconv.rs @@ -87,8 +87,8 @@ fn ast_path_to_substs_and_ty<AC: ast_conv, RS: region_scope copy owned>( let {bounds: decl_bounds, rp: decl_rp, ty: decl_ty} = self.get_item_ty(did); - #debug["ast_path_to_substs_and_ty: did=%? decl_rp=%b", - did, decl_rp]; + debug!{"ast_path_to_substs_and_ty: did=%? decl_rp=%b", + did, decl_rp}; // If the type is parameterized by the self region, then replace self // region with the current anon region binding (in other words, @@ -100,9 +100,9 @@ fn ast_path_to_substs_and_ty<AC: ast_conv, RS: region_scope copy owned>( (false, some(_)) { tcx.sess.span_err( path.span, - #fmt["no region bound is allowed on `%s`, \ + fmt!{"no region bound is allowed on `%s`, \ which is not declared as containing region pointers", - ty::item_path_str(tcx, did)]); + ty::item_path_str(tcx, did)}); none } (true, none) { @@ -119,8 +119,8 @@ fn ast_path_to_substs_and_ty<AC: ast_conv, RS: region_scope copy owned>( if !vec::same_length(*decl_bounds, path.types) { self.tcx().sess.span_fatal( path.span, - #fmt["wrong number of type arguments: expected %u but found %u", - (*decl_bounds).len(), path.types.len()]); + fmt!{"wrong number of type arguments: expected %u but found %u", + (*decl_bounds).len(), path.types.len()}); } let tps = path.types.map(|a_t| ast_ty_to_ty(self, rscope, a_t)); @@ -266,8 +266,8 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( } ast::ty_path(path, id) { let a_def = alt tcx.def_map.find(id) { - none { tcx.sess.span_fatal(ast_ty.span, #fmt("unbound path %s", - path_to_str(path))); } + none { tcx.sess.span_fatal(ast_ty.span, fmt!{"unbound path %s", + path_to_str(path)}); } some(d) { d }}; alt a_def { ast::def_ty(did) | ast::def_class(did, _) { @@ -322,8 +322,8 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>( |ty| { tcx.sess.span_err( a_t.span, - #fmt["bound not allowed on a %s", - ty::ty_sort_str(tcx, ty.ty)]); + fmt!{"bound not allowed on a %s", + ty::ty_sort_str(tcx, ty.ty)}); ty.ty }) } @@ -400,7 +400,7 @@ fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy owned>( decl: ast::fn_decl, expected_tys: expected_tys) -> ty::fn_ty { - #debug["ty_of_fn_decl"]; + debug!{"ty_of_fn_decl"}; do indent { // new region names that appear inside of the fn decl are bound to // that function type diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index e7575ff0f1f..1f589a1b960 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -201,10 +201,10 @@ fn check_fn(ccx: @crate_ctxt, let arg_tys = fn_ty.inputs.map(|a| a.ty); let ret_ty = fn_ty.output; - #debug["check_fn(arg_tys=%?, ret_ty=%?, self_ty=%?)", + debug!{"check_fn(arg_tys=%?, ret_ty=%?, self_ty=%?)", arg_tys.map(|a| ty_to_str(tcx, a)), ty_to_str(tcx, ret_ty), - option::map(self_ty, |st| ty_to_str(tcx, st))]; + option::map(self_ty, |st| ty_to_str(tcx, st))}; // ______________________________________________________________________ // Create the function context. This is either derived from scratch or, @@ -299,8 +299,8 @@ fn check_fn(ccx: @crate_ctxt, // Add formal parameters. do vec::iter2(arg_tys, decl.inputs) |arg_ty, input| { assign(input.id, some(arg_ty)); - #debug["Argument %s is assigned to %s", - *input.ident, fcx.locals.get(input.id).to_str()]; + debug!{"Argument %s is assigned to %s", + *input.ident, fcx.locals.get(input.id).to_str()}; } // Add explicitly-declared locals. @@ -311,9 +311,9 @@ fn check_fn(ccx: @crate_ctxt, _ { some(fcx.to_ty(local.node.ty)) } }; assign(local.node.id, o_ty); - #debug["Local variable %s is assigned to %s", + debug!{"Local variable %s is assigned to %s", pat_to_str(local.node.pat), - fcx.locals.get(local.node.id).to_str()]; + fcx.locals.get(local.node.id).to_str()}; visit::visit_local(local, e, v); }; @@ -323,9 +323,9 @@ fn check_fn(ccx: @crate_ctxt, ast::pat_ident(path, _) if !pat_util::pat_is_variant(fcx.ccx.tcx.def_map, p) { assign(p.id, none); - #debug["Pattern binding %s is assigned to %s", + debug!{"Pattern binding %s is assigned to %s", *path.idents[0], - fcx.locals.get(p.id).to_str()]; + fcx.locals.get(p.id).to_str()}; } _ {} } @@ -381,9 +381,9 @@ fn check_no_duplicate_fields(tcx: ty::ctxt, fields: let (id, sp) = p; alt field_names.find(id) { some(orig_sp) { - tcx.sess.span_err(sp, #fmt("Duplicate field \ + tcx.sess.span_err(sp, fmt!{"Duplicate field \ name %s in record type declaration", - *id)); + *id}); tcx.sess.span_note(orig_sp, ~"First declaration of \ this field occurred here"); break; @@ -407,8 +407,8 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { } ast::item_impl(tps, _, ty, ms) { let rp = ccx.tcx.region_paramd_items.contains_key(it.id); - #debug["item_impl %s with id %d rp %b", - *it.ident, it.id, rp]; + debug!{"item_impl %s with id %d rp %b", + *it.ident, it.id, rp}; let self_ty = ccx.to_ty(rscope::type_rscope(rp), ty); for ms.each |m| { check_method(ccx, m, self_ty);} } @@ -470,7 +470,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { if (*tpt.bounds).is_not_empty() { ccx.tcx.sess.span_err( item.span, - #fmt["foreign items may not have type parameters"]); + fmt!{"foreign items may not have type parameters"}); } } } @@ -502,7 +502,7 @@ impl of region_scope for @fn_ctxt { some(r) { result::ok(r) } none if *id == ~"blk" { self.block_region() } none { - result::err(#fmt["named region `%s` not in scope here", *id]) + result::err(fmt!{"named region `%s` not in scope here", *id}) } } } @@ -510,14 +510,14 @@ impl of region_scope for @fn_ctxt { } impl methods for @fn_ctxt { - fn tag() -> ~str { #fmt["%x", ptr::addr_of(*self) as uint] } + fn tag() -> ~str { fmt!{"%x", ptr::addr_of(*self) as uint} } fn block_region() -> result<ty::region, ~str> { result::ok(ty::re_scope(self.region_lb)) } #[inline(always)] fn write_ty(node_id: ast::node_id, ty: ty::t) { - #debug["write_ty(%d, %s) in fcx %s", - node_id, ty_to_str(self.tcx(), ty), self.tag()]; + debug!{"write_ty(%d, %s) in fcx %s", + node_id, ty_to_str(self.tcx(), ty), self.tag()}; self.node_types.insert(node_id, ty); } fn write_substs(node_id: ast::node_id, +substs: ty::substs) { @@ -546,8 +546,8 @@ impl methods for @fn_ctxt { alt self.node_types.find(ex.id) { some(t) { t } none { - self.tcx().sess.bug(#fmt["no type for expr %d (%s) in fcx %s", - ex.id, expr_to_str(ex), self.tag()]); + self.tcx().sess.bug(fmt!{"no type for expr %d (%s) in fcx %s", + ex.id, expr_to_str(ex), self.tag()}); } } } @@ -556,9 +556,9 @@ impl methods for @fn_ctxt { some(t) { t } none { self.tcx().sess.bug( - #fmt["no type for node %d: %s in fcx %s", + fmt!{"no type for node %d: %s in fcx %s", id, ast_map::node_id_to_str(self.tcx().items, id), - self.tag()]); + self.tag()}); } } } @@ -567,9 +567,9 @@ impl methods for @fn_ctxt { some(ts) { ts } none { self.tcx().sess.bug( - #fmt["no type substs for node %d: %s in fcx %s", + fmt!{"no type substs for node %d: %s in fcx %s", id, ast_map::node_id_to_str(self.tcx().items, id), - self.tag()]); + self.tag()}); } } } @@ -581,10 +581,10 @@ impl methods for @fn_ctxt { err: ty::type_err) { self.ccx.tcx.sess.span_err( sp, - #fmt["mismatched types: expected `%s` but found `%s` (%s)", + fmt!{"mismatched types: expected `%s` but found `%s` (%s)", self.infcx.ty_to_str(e), self.infcx.ty_to_str(a), - ty::type_err_to_str(self.ccx.tcx, err)]); + ty::type_err_to_str(self.ccx.tcx, err)}); } fn mk_subty(sub: ty::t, sup: ty::t) -> result<(), ty::type_err> { @@ -621,7 +621,7 @@ impl methods for @fn_ctxt { _ { self.ccx.tcx.sess.span_err( sp, - #fmt["%s requires unsafe function or block", op]); + fmt!{"%s requires unsafe function or block", op}); } } } @@ -775,8 +775,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expected: option<ty::t>, unifier: fn()) -> bool { - #debug(">> typechecking expr %d (%s)", - expr.id, syntax::print::pprust::expr_to_str(expr)); + debug!{">> typechecking expr %d (%s)", + expr.id, syntax::print::pprust::expr_to_str(expr)}; // A generic function to factor out common logic from call and // overloaded operations @@ -789,8 +789,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, // Replace all region parameters in the arguments and return // type with fresh region variables. - #debug["check_call_inner: before universal quant., in_fty=%s", - fcx.infcx.ty_to_str(in_fty)]; + debug!{"check_call_inner: before universal quant., in_fty=%s", + fcx.infcx.ty_to_str(in_fty)}; // This is subtle: we expect `fty` to be a function type, which // normally introduce a level of binding. In this case, we want to @@ -815,8 +815,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, }; let fty = ty::mk_fn(fcx.tcx(), fn_ty); - #debug["check_call_inner: after universal quant., fty=%s", - fcx.infcx.ty_to_str(fty)]; + debug!{"check_call_inner: after universal quant., fty=%s", + fcx.infcx.ty_to_str(fty)}; let supplied_arg_count = vec::len(args); @@ -827,7 +827,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, fn_ty.inputs.map(|a| a.ty) } else { fcx.ccx.tcx.sess.span_err( - sp, #fmt["this function takes %u parameter%s but %u \ + sp, fmt!{"this function takes %u parameter%s but %u \ parameter%s supplied", expected_arg_count, if expected_arg_count == 1u { ~"" @@ -839,7 +839,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ~" was" } else { ~"s were" - }]); + }}); fcx.infcx.next_ty_vars(supplied_arg_count) }; @@ -999,8 +999,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, // separate case below. tcx.sess.span_bug( expr.span, - #fmt["comparison operator in expr_binop: %s", - ast_util::binop_to_str(op)]); + fmt!{"comparison operator in expr_binop: %s", + ast_util::binop_to_str(op)}); } _ { lhs_t } }; @@ -1061,8 +1061,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, some((ret_ty, _)) { ret_ty } _ { fcx.ccx.tcx.sess.span_err( - ex.span, #fmt["cannot apply unary operator `%s` to type `%s`", - op_str, fcx.infcx.ty_to_str(rhs_t)]); + ex.span, fmt!{"cannot apply unary operator `%s` to type `%s`", + op_str, fcx.infcx.ty_to_str(rhs_t)}); rhs_t } } @@ -1118,8 +1118,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, decl, expected_tys); let fty = ty::mk_fn(tcx, fn_ty); - #debug("check_expr_fn_with_unifier %s fty=%s", - expr_to_str(expr), fcx.infcx.ty_to_str(fty)); + debug!{"check_expr_fn_with_unifier %s fty=%s", + expr_to_str(expr), fcx.infcx.ty_to_str(fty)}; fcx.write_ty(expr.id, fty); @@ -1159,7 +1159,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, // (1) verify that the class id actually has a field called // field - #debug("class named %s", ty_to_str(tcx, base_t)); + debug!{"class named %s", ty_to_str(tcx, base_t)}; /* check whether this is a self-reference or not, which determines whether we look at all fields or only public @@ -1209,10 +1209,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } none { let t_err = fcx.infcx.resolve_type_vars_if_possible(expr_t); - let msg = #fmt["attempted access of field `%s` on type `%s`, \ + let msg = fmt!{"attempted access of field `%s` on type `%s`, \ but no public field or method with that name \ was found", - *field, fcx.infcx.ty_to_str(t_err)]; + *field, fcx.infcx.ty_to_str(t_err)}; tcx.sess.span_err(expr.span, msg); // NB: Adding a bogus type to allow typechecking to continue fcx.write_ty(expr.id, fcx.infcx.next_ty_var()); @@ -1334,8 +1334,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, _ { tcx.sess.span_err( expr.span, - #fmt["type %s cannot be dereferenced", - fcx.infcx.ty_to_str(oprnd_t)]); + fmt!{"type %s cannot be dereferenced", + fcx.infcx.ty_to_str(oprnd_t)}); } } } @@ -1472,9 +1472,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, result::ok(_) {} result::err(err) { tcx.sess.span_fatal( - expr.span, #fmt("a `loop` function's last argument \ + expr.span, fmt!{"a `loop` function's last argument \ should return `bool`, not `%s`", - fcx.infcx.ty_to_str(fty.output))); + fcx.infcx.ty_to_str(fty.output)}); } } (ty::mk_fn(tcx, {output: ty::mk_nil(tcx) with fty}), fty.proto) @@ -1545,8 +1545,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let t_1 = fcx.to_ty(t); let t_e = fcx.expr_ty(e); - #debug["t_1=%s", fcx.infcx.ty_to_str(t_1)]; - #debug["t_e=%s", fcx.infcx.ty_to_str(t_e)]; + debug!{"t_1=%s", fcx.infcx.ty_to_str(t_1)}; + debug!{"t_e=%s", fcx.infcx.ty_to_str(t_e)}; alt ty::get(t_1).struct { // This will be looked up later on @@ -1743,15 +1743,15 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, alt class_field_map.find(*field.node.ident) { none => { tcx.sess.span_err(field.span, - #fmt("structure has no field named \ + fmt!{"structure has no field named \ field named `%s`", - *field.node.ident)); + *field.node.ident}); } some((_, true)) => { tcx.sess.span_err(field.span, - #fmt("field `%s` specified more than \ + fmt!{"field `%s` specified more than \ once", - *field.node.ident)); + *field.node.ident}); } some((field_id, false)) => { let expected_field_type = @@ -1779,13 +1779,13 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } tcx.sess.span_err(expr.span, - #fmt("missing field%s: %s", + fmt!{"missing field%s: %s", if missing_fields.len() == 1 { ~"" } else { ~"s" }, - str::connect(missing_fields, ~", "))); + str::connect(missing_fields, ~", ")}); } // Write in the resulting type. @@ -1851,8 +1851,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, none { let t_err = fcx.infcx.resolve_type_vars_if_possible(p_ty); - let msg = #fmt["no `alloc()` method found for type `%s`", - fcx.infcx.ty_to_str(t_err)]; + let msg = fmt!{"no `alloc()` method found for type `%s`", + fcx.infcx.ty_to_str(t_err)}; tcx.sess.span_err(expr.span, msg); } } @@ -1868,17 +1868,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } if bot { fcx.write_bot(expr.id); } - #debug("type of expr %s is %s, expected is %s", + debug!{"type of expr %s is %s, expected is %s", syntax::print::pprust::expr_to_str(expr), ty_to_str(tcx, fcx.expr_ty(expr)), alt expected { some(t) { ty_to_str(tcx, t) } _ { ~"empty" } - }); + }}; unifier(); - #debug("<< bot=%b", bot); + debug!{"<< bot=%b", bot}; ret bot; } @@ -2025,10 +2025,10 @@ fn check_instantiable(tcx: ty::ctxt, item_id: ast::node_id) { let item_ty = ty::node_id_to_type(tcx, item_id); if !ty::is_instantiable(tcx, item_ty) { - tcx.sess.span_err(sp, #fmt["this type cannot be instantiated \ + tcx.sess.span_err(sp, fmt!{"this type cannot be instantiated \ without an instance of itself; \ consider using `option<%s>`", - ty_to_str(tcx, item_ty)]); + ty_to_str(tcx, item_ty)}); } } @@ -2299,7 +2299,7 @@ fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint, ast::vstore_fixed(none) { ty::vstore_fixed(n) } ast::vstore_fixed(some(u)) { if n != u { - let s = #fmt("fixed-size sequence mismatch: %u vs. %u",u, n); + let s = fmt!{"fixed-size sequence mismatch: %u vs. %u",u, n}; fcx.ccx.tcx.sess.span_err(e.span,s); } ty::vstore_fixed(u) @@ -2344,7 +2344,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt, for tps_used.eachi |i, b| { if !b { ccx.tcx.sess.span_err( - span, #fmt["type parameter `%s` is unused", *tps[i].ident]); + span, fmt!{"type parameter `%s` is unused", *tps[i].ident}); } } } @@ -2424,14 +2424,14 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) { let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id)); let i_n_tps = (*i_ty.bounds).len(); if i_n_tps != n_tps { - tcx.sess.span_err(it.span, #fmt("intrinsic has wrong number \ + tcx.sess.span_err(it.span, fmt!{"intrinsic has wrong number \ of type parameters: found %u, \ - expected %u", i_n_tps, n_tps)); + expected %u", i_n_tps, n_tps}); } else { require_same_types( tcx, none, it.span, i_ty.ty, fty, - || #fmt["intrinsic has wrong type: \ + || fmt!{"intrinsic has wrong type: \ expected `%s`", - ty_to_str(ccx.tcx, fty)]); + ty_to_str(ccx.tcx, fty)}); } } diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index 2b32c8e3564..db35398a49c 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -88,12 +88,12 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, if arg_len > 0u { // N-ary variant. if arg_len != subpats_len { - let s = #fmt["this pattern has %u field%s, but the \ + 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" }, arg_len, - if arg_len == 1u { ~"" } else { ~"s" }]; + if arg_len == 1u { ~"" } else { ~"s" }}; tcx.sess.span_fatal(pat.span, s); } @@ -104,18 +104,18 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, }; } else if subpats_len > 0u { tcx.sess.span_fatal - (pat.span, #fmt["this pattern has %u field%s, \ + (pat.span, fmt!{"this pattern has %u field%s, \ but the corresponding variant has no fields", subpats_len, if subpats_len == 1u { ~"" } - else { ~"s" }]); + else { ~"s" }}); } } _ { tcx.sess.span_fatal (pat.span, - #fmt["mismatched types: expected enum but found `%s`", - fcx.infcx.ty_to_str(expected)]); + fmt!{"mismatched types: expected enum but found `%s`", + fcx.infcx.ty_to_str(expected)}); } } } @@ -141,8 +141,8 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { fcx.infcx.resolve_type_vars_if_possible(fcx.expr_ty(begin)); let e_ty = fcx.infcx.resolve_type_vars_if_possible(fcx.expr_ty(end)); - #debug["pat_range beginning type: %?", b_ty]; - #debug["pat_range ending type: %?", e_ty]; + debug!{"pat_range beginning type: %?", b_ty}; + 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") { @@ -183,18 +183,18 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { _ { tcx.sess.span_fatal (pat.span, - #fmt["mismatched types: expected `%s` but found record", - fcx.infcx.ty_to_str(expected)]); + fmt!{"mismatched types: expected `%s` but found record", + fcx.infcx.ty_to_str(expected)}); } }; let f_count = vec::len(fields); let ex_f_count = vec::len(ex_fields); if ex_f_count < f_count || !etc && ex_f_count > f_count { tcx.sess.span_fatal - (pat.span, #fmt["mismatched types: expected a record \ + (pat.span, fmt!{"mismatched types: expected a record \ with %u fields, found one with %u \ fields", - ex_f_count, f_count]); + ex_f_count, f_count}); } fn matches(name: ast::ident, f: ty::field) -> bool { ret str::eq(*name, *f.ident); @@ -206,9 +206,9 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { } none { tcx.sess.span_fatal(pat.span, - #fmt["mismatched types: did not \ + fmt!{"mismatched types: did not \ expect a record with a field `%s`", - *f.ident]); + *f.ident}); } } } @@ -220,16 +220,16 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { _ { tcx.sess.span_fatal (pat.span, - #fmt["mismatched types: expected `%s`, found tuple", - fcx.infcx.ty_to_str(expected)]); + fmt!{"mismatched types: expected `%s`, found tuple", + fcx.infcx.ty_to_str(expected)}); } }; let e_count = vec::len(elts); if e_count != vec::len(ex_elts) { tcx.sess.span_fatal - (pat.span, #fmt["mismatched types: expected a tuple \ + (pat.span, fmt!{"mismatched types: expected a tuple \ with %u fields, found one with %u \ - fields", vec::len(ex_elts), e_count]); + fields", vec::len(ex_elts), e_count}); } let mut i = 0u; for elts.each |elt| { diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs index 585d0ccf5cf..277891c4eff 100644 --- a/src/rustc/middle/typeck/check/method.rs +++ b/src/rustc/middle/typeck/check/method.rs @@ -58,9 +58,9 @@ class lookup { // Entrypoint: fn method() -> option<method_map_entry> { - #debug["method lookup(m_name=%s, self_ty=%s, %?)", + debug!{"method lookup(m_name=%s, self_ty=%s, %?)", *self.m_name, self.fcx.infcx.ty_to_str(self.self_ty), - ty::get(self.self_ty).struct]; + ty::get(self.self_ty).struct}; // Determine if there are any inherent methods we can call. let optional_inherent_methods; @@ -71,15 +71,15 @@ class lookup { optional_inherent_methods = none; } some(base_type_def_id) { - #debug("(checking method) found base type"); + debug!{"(checking method) found base type"}; optional_inherent_methods = self.fcx.ccx.coherence_info.inherent_methods.find (base_type_def_id); if optional_inherent_methods.is_none() { - #debug("(checking method) ... no inherent methods found"); + debug!{"(checking method) ... no inherent methods found"}; } else { - #debug("(checking method) ... inherent methods found"); + debug!{"(checking method) ... inherent methods found"}; } } } @@ -173,30 +173,30 @@ class lookup { }; self.tcx().sess.span_note( span, - #fmt["candidate #%u is `%s`", + fmt!{"candidate #%u is `%s`", (idx+1u), - ty::item_path_str(self.tcx(), did)]); + ty::item_path_str(self.tcx(), did)}); } fn report_param_candidate(idx: uint, did: ast::def_id) { self.tcx().sess.span_note( self.expr.span, - #fmt["candidate #%u derives from the bound `%s`", + fmt!{"candidate #%u derives from the bound `%s`", (idx+1u), - ty::item_path_str(self.tcx(), did)]); + ty::item_path_str(self.tcx(), did)}); } fn report_trait_candidate(idx: uint, did: ast::def_id) { self.tcx().sess.span_note( self.expr.span, - #fmt["candidate #%u derives from the type of the receiver, \ + fmt!{"candidate #%u derives from the type of the receiver, \ which is the trait `%s`", (idx+1u), - ty::item_path_str(self.tcx(), did)]); + ty::item_path_str(self.tcx(), did)}); } fn add_candidates_from_param(n: uint, did: ast::def_id) { - #debug["candidates_from_param"]; + debug!{"candidates_from_param"}; let tcx = self.tcx(); let mut trait_bnd_idx = 0u; // count only trait bounds @@ -246,7 +246,7 @@ class lookup { fn add_candidates_from_trait(did: ast::def_id, trait_substs: ty::substs) { - #debug["method_from_trait"]; + debug!{"method_from_trait"}; let ms = *ty::trait_methods(self.tcx(), did); for ms.eachi |i, m| { @@ -281,7 +281,7 @@ class lookup { fn add_candidates_from_class(did: ast::def_id, class_substs: ty::substs) { - #debug["method_from_class"]; + debug!{"method_from_class"}; let ms = *ty::trait_methods(self.tcx(), did); @@ -341,7 +341,7 @@ class lookup { let impls_vecs = self.fcx.ccx.impl_map.get(self.expr.id); let mut added_any = false; - #debug["method_from_scope"]; + debug!{"method_from_scope"}; for list::each(impls_vecs) |impls| { for vec::each(*impls) |im| { @@ -379,7 +379,7 @@ class lookup { } else { self.fcx.can_mk_subty(self.self_ty, impl_ty) }; - #debug["matches = %?", matches]; + debug!{"matches = %?", matches}; alt matches { result::err(_) { /* keep looking */ } result::ok(_) { @@ -431,13 +431,13 @@ class lookup { // Continue. } some(inherent_methods) { - #debug("(adding inherent and extension candidates) adding \ - inherent candidates"); + debug!{"(adding inherent and extension candidates) adding \ + inherent candidates"}; for inherent_methods.each |implementation| { - #debug("(adding inherent and extension candidates) \ + debug!{"(adding inherent and extension candidates) \ adding candidates from impl: %s", node_id_to_str(self.tcx().items, - implementation.did.node)); + implementation.did.node)}; self.add_candidates_from_impl(implementation, use_assignability); } @@ -451,9 +451,9 @@ class lookup { } some(trait_ids) { for (*trait_ids).each |trait_id| { - #debug("(adding inherent and extension candidates) \ + debug!{"(adding inherent and extension candidates) \ trying trait: %s", - self.def_id_to_str(trait_id)); + self.def_id_to_str(trait_id)}; let coherence_info = self.fcx.ccx.coherence_info; alt coherence_info.extension_methods.find(trait_id) { @@ -462,10 +462,10 @@ class lookup { } some(extension_methods) { for extension_methods.each |implementation| { - #debug("(adding inherent and extension \ + debug!{"(adding inherent and extension \ candidates) adding impl %s", self.def_id_to_str - (implementation.did)); + (implementation.did)}; self.add_candidates_from_impl (implementation, use_assignability); } @@ -487,10 +487,10 @@ class lookup { fn write_mty_from_candidate(cand: candidate) -> method_map_entry { let tcx = self.fcx.ccx.tcx; - #debug["write_mty_from_candidate(n_tps_m=%u, fty=%s, entry=%?)", + debug!{"write_mty_from_candidate(n_tps_m=%u, fty=%s, entry=%?)", cand.n_tps_m, self.fcx.infcx.ty_to_str(cand.fty), - cand.entry]; + cand.entry}; // Make the actual receiver type (cand.self_ty) assignable to the // required receiver type (cand.rcvr_ty). If this method is not @@ -501,9 +501,9 @@ class lookup { result::err(_) { self.tcx().sess.span_bug( self.expr.span, - #fmt["%s was assignable to %s but now is not?", + fmt!{"%s was assignable to %s but now is not?", self.fcx.infcx.ty_to_str(cand.self_ty), - self.fcx.infcx.ty_to_str(cand.rcvr_ty)]); + self.fcx.infcx.ty_to_str(cand.rcvr_ty)}); } } diff --git a/src/rustc/middle/typeck/check/regionck.rs b/src/rustc/middle/typeck/check/regionck.rs index 850181576ab..06307c1c70c 100644 --- a/src/rustc/middle/typeck/check/regionck.rs +++ b/src/rustc/middle/typeck/check/regionck.rs @@ -107,7 +107,7 @@ fn visit_pat(p: @ast::pat, &&rcx: @rcx, v: rvt) { alt p.node { ast::pat_ident(path, _) if !pat_util::pat_is_variant(fcx.ccx.tcx.def_map, p) { - #debug["visit_pat binding=%s", *path.idents[0]]; + debug!{"visit_pat binding=%s", *path.idents[0]}; visit_node(p.id, p.span, rcx); } _ {} @@ -121,7 +121,7 @@ fn visit_block(b: ast::blk, &&rcx: @rcx, v: rvt) { } fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) { - #debug["visit_expr(e=%s)", pprust::expr_to_str(e)]; + debug!{"visit_expr(e=%s)", pprust::expr_to_str(e)}; alt e.node { ast::expr_path(*) { @@ -200,10 +200,10 @@ fn visit_node(id: ast::node_id, span: span, rcx: @rcx) -> bool { let tcx = fcx.ccx.tcx; let encl_region = ty::encl_region(tcx, id); - #debug["visit_node(ty=%s, id=%d, encl_region=%s)", + debug!{"visit_node(ty=%s, id=%d, encl_region=%s)", ppaux::ty_to_str(tcx, ty), id, - ppaux::region_to_str(tcx, encl_region)]; + ppaux::region_to_str(tcx, encl_region)}; // Otherwise, look at the type and see if it is a region pointer. ret constrain_regions_in_type(rcx, encl_region, span, ty); @@ -228,9 +228,9 @@ fn constrain_regions_in_type( region: ty::region) { let tcx = rcx.fcx.ccx.tcx; - #debug["constrain_region(encl_region=%s, region=%s)", + debug!{"constrain_region(encl_region=%s, region=%s)", ppaux::region_to_str(tcx, encl_region), - ppaux::region_to_str(tcx, region)]; + ppaux::region_to_str(tcx, region)}; alt region { ty::re_bound(_) { @@ -248,9 +248,9 @@ fn constrain_regions_in_type( let region1 = rcx.fcx.infcx.resolve_region_if_possible(region); tcx.sess.span_err( span, - #fmt["reference is not valid outside \ + fmt!{"reference is not valid outside \ of its lifetime, %s", - ppaux::region_to_str(tcx, region1)]); + ppaux::region_to_str(tcx, region1)}); rcx.errors_reported += 1u; } result::ok(()) { diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs index 06455e8887a..efb50b1eb8f 100644 --- a/src/rustc/middle/typeck/check/regionmanip.rs +++ b/src/rustc/middle/typeck/check/regionmanip.rs @@ -14,14 +14,14 @@ fn replace_bound_regions_in_fn_ty( let mut all_tys = ty::tys_in_fn_ty(fn_ty); for self_ty.each |t| { vec::push(all_tys, t) } - #debug["replace_bound_regions_in_fn_ty(self_ty=%?, fn_ty=%s, all_tys=%?)", + debug!{"replace_bound_regions_in_fn_ty(self_ty=%?, fn_ty=%s, all_tys=%?)", self_ty.map(|t| ty_to_str(tcx, t)), ty_to_str(tcx, ty::mk_fn(tcx, fn_ty)), - all_tys.map(|t| ty_to_str(tcx, t))]; + all_tys.map(|t| ty_to_str(tcx, t))}; let _i = indenter(); let isr = do create_bound_region_mapping(tcx, isr, all_tys) |br| { - #debug["br=%?", br]; + debug!{"br=%?", br}; mapf(br) }; let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(fn_ty), |t| { @@ -29,9 +29,9 @@ fn replace_bound_regions_in_fn_ty( }); let t_self = self_ty.map(|t| replace_bound_regions(tcx, isr, t)); - #debug["result of replace_bound_regions_in_fn_ty: self_ty=%?, fn_ty=%s", + debug!{"result of replace_bound_regions_in_fn_ty: self_ty=%?, fn_ty=%s", t_self.map(|t| ty_to_str(tcx, t)), - ty_to_str(tcx, t_fn)]; + ty_to_str(tcx, t_fn)}; ret {isr: isr, self_ty: t_self, @@ -122,9 +122,9 @@ fn replace_bound_regions_in_fn_ty( none if in_fn { r } none { tcx.sess.bug( - #fmt["Bound region not found in \ + fmt!{"Bound region not found in \ in_scope_regions list: %s", - region_to_str(tcx, r)]); + region_to_str(tcx, r)}); } } } @@ -145,7 +145,7 @@ fn replace_bound_regions_in_fn_ty( * stack position and so the resulting region will be the enclosing block. */ fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region { - #debug["region_of(expr=%s)", expr_to_str(expr)]; + debug!{"region_of(expr=%s)", expr_to_str(expr)}; ret alt expr.node { ast::expr_path(path) { def(fcx, expr, lookup_def(fcx, path.span, expr.id))} @@ -178,12 +178,12 @@ fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region { ast::def_arg(local_id, _) | ast::def_local(local_id, _) | ast::def_binding(local_id) { - #debug["region_of.def/arg/local/binding(id=%d)", local_id]; + debug!{"region_of.def/arg/local/binding(id=%d)", local_id}; let local_scope = fcx.ccx.tcx.region_map.get(local_id); ty::re_scope(local_scope) } ast::def_upvar(_, inner, _) { - #debug["region_of.def/upvar"]; + debug!{"region_of.def/upvar"}; def(fcx, expr, *inner) } ast::def_self(*) { diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index f023f3aeae7..70fddb190fb 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -56,8 +56,8 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, allow_unsafe: bool) -> vtable_origin { - #debug["lookup_vtable(ty=%s, trait_ty=%s)", - fcx.infcx.ty_to_str(ty), fcx.infcx.ty_to_str(trait_ty)]; + debug!{"lookup_vtable(ty=%s, trait_ty=%s)", + fcx.infcx.ty_to_str(ty), fcx.infcx.ty_to_str(trait_ty)}; let _i = indenter(); let tcx = fcx.ccx.tcx; @@ -78,8 +78,8 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, alt check ty::get(ity).struct { ty::ty_trait(idid, substs) { if trait_id == idid { - #debug("(checking vtable) @0 relating ty to trait ty - with did %?", idid); + debug!{"(checking vtable) @0 relating ty to trait ty + with did %?", idid}; relate_trait_tys(fcx, sp, trait_ty, ity); ret vtable_param(n, n_bound); } @@ -92,8 +92,8 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, } ty::ty_trait(did, substs) if trait_id == did { - #debug("(checking vtable) @1 relating ty to trait ty with did %?", - did); + debug!{"(checking vtable) @1 relating ty to trait ty with did %?", + did}; relate_trait_tys(fcx, sp, trait_ty, ty); if !allow_unsafe { @@ -153,10 +153,10 @@ fn lookup_vtable(fcx: @fn_ctxt, sp: span, ty: ty::t, trait_ty: ty::t, } // check that desired trait type unifies - #debug("(checking vtable) @2 relating trait ty %s to \ + debug!{"(checking vtable) @2 relating trait ty %s to \ of_ty %s", fcx.infcx.ty_to_str(trait_ty), - fcx.infcx.ty_to_str(of_ty)); + fcx.infcx.ty_to_str(of_ty)}; let of_ty = ty::subst(tcx, substs, of_ty); relate_trait_tys(fcx, sp, trait_ty, of_ty); @@ -201,9 +201,9 @@ fn fixup_ty(fcx: @fn_ctxt, sp: span, ty: ty::t) -> ty::t { result::err(e) { tcx.sess.span_fatal( sp, - #fmt["cannot determine a type \ + fmt!{"cannot determine a type \ for this bounded type parameter: %s", - fixup_err_to_str(e)]) + fixup_err_to_str(e)}) } } } @@ -215,8 +215,8 @@ fn connect_trait_tps(fcx: @fn_ctxt, sp: span, impl_tys: ~[ty::t], // XXX: This should work for multiple traits. let ity = ty::impl_traits(tcx, impl_did)[0]; let trait_ty = ty::subst_tps(tcx, impl_tys, ity); - #debug("(connect trait tps) trait type is %?, impl did is %?", - ty::get(trait_ty).struct, impl_did); + debug!{"(connect trait tps) trait type is %?, impl did is %?", + ty::get(trait_ty).struct, impl_did}; alt check ty::get(trait_ty).struct { ty::ty_trait(_, substs) { vec::iter2(substs.tps, trait_tys, diff --git a/src/rustc/middle/typeck/check/writeback.rs b/src/rustc/middle/typeck/check/writeback.rs index f97ff61dbf4..d9615c88583 100644 --- a/src/rustc/middle/typeck/check/writeback.rs +++ b/src/rustc/middle/typeck/check/writeback.rs @@ -16,9 +16,9 @@ fn resolve_type_vars_in_type(fcx: @fn_ctxt, sp: span, typ: ty::t) -> if !fcx.ccx.tcx.sess.has_errors() { fcx.ccx.tcx.sess.span_err( sp, - #fmt["cannot determine a type \ + fmt!{"cannot determine a type \ for this expression: %s", - infer::fixup_err_to_str(e)]) + infer::fixup_err_to_str(e)}) } ret none; } @@ -35,8 +35,8 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id) } some(t) { - #debug["resolve_type_vars_for_node(id=%d, n_ty=%s, t=%s)", - id, ty_to_str(tcx, n_ty), ty_to_str(tcx, t)]; + debug!{"resolve_type_vars_for_node(id=%d, n_ty=%s, t=%s)", + id, ty_to_str(tcx, n_ty), ty_to_str(tcx, t)}; write_ty_to_tcx(tcx, id, t); alt fcx.opt_node_ty_substs(id) { some(substs) { @@ -120,11 +120,11 @@ fn visit_block(b: ast::blk, wbcx: wb_ctxt, v: wb_vt) { fn visit_pat(p: @ast::pat, wbcx: wb_ctxt, v: wb_vt) { if !wbcx.success { ret; } resolve_type_vars_for_node(wbcx, p.span, p.id); - #debug["Type for pattern binding %s (id %d) resolved to %s", + debug!{"Type for pattern binding %s (id %d) resolved to %s", pat_to_str(p), p.id, wbcx.fcx.infcx.ty_to_str( ty::node_id_to_type(wbcx.fcx.ccx.tcx, - p.id))]; + p.id))}; visit::visit_pat(p, wbcx, v); } fn visit_local(l: @ast::local, wbcx: wb_ctxt, v: wb_vt) { @@ -133,17 +133,17 @@ fn visit_local(l: @ast::local, wbcx: wb_ctxt, v: wb_vt) { let var_ty = ty::mk_var(wbcx.fcx.tcx(), var_id); alt resolve_type(wbcx.fcx.infcx, var_ty, resolve_all | force_all) { result::ok(lty) { - #debug["Type for local %s (id %d) resolved to %s", + debug!{"Type for local %s (id %d) resolved to %s", pat_to_str(l.node.pat), l.node.id, - wbcx.fcx.infcx.ty_to_str(lty)]; + wbcx.fcx.infcx.ty_to_str(lty)}; write_ty_to_tcx(wbcx.fcx.ccx.tcx, l.node.id, lty); } result::err(e) { wbcx.fcx.ccx.tcx.sess.span_err( l.span, - #fmt["cannot determine a type \ + fmt!{"cannot determine a type \ for this local variable: %s", - infer::fixup_err_to_str(e)]); + infer::fixup_err_to_str(e)}); wbcx.success = false; } } diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs index 005f87e601b..e3fdd0424b7 100644 --- a/src/rustc/middle/typeck/coherence.rs +++ b/src/rustc/middle/typeck/coherence.rs @@ -60,13 +60,13 @@ fn get_base_type(inference_context: infer_ctxt, span: span, original_type: t) ty_uniq(base_mutability_and_type) | ty_ptr(base_mutability_and_type) | ty_rptr(_, base_mutability_and_type) { - #debug("(getting base type) recurring"); + debug!{"(getting base type) recurring"}; get_base_type(inference_context, span, base_mutability_and_type.ty) } ty_enum(*) | ty_trait(*) | ty_class(*) { - #debug("(getting base type) found base type"); + debug!{"(getting base type) found base type"}; some(resolved_type) } @@ -75,8 +75,8 @@ fn get_base_type(inference_context: infer_ctxt, span: span, original_type: t) ty_fn(*) | ty_tup(*) | ty_var(*) | ty_var_integral(*) | ty_param(*) | ty_self | ty_type | ty_opaque_box | ty_opaque_closure_ptr(*) | ty_unboxed_vec(*) { - #debug("(getting base type) no base type; found %?", - get(original_type).struct); + debug!{"(getting base type) no base type; found %?", + get(original_type).struct}; none } } @@ -158,7 +158,7 @@ class CoherenceChecker { visit_crate(*crate, (), mk_simple_visitor(@{ visit_item: |item| { - #debug("(checking coherence) item '%s'", *item.ident); + debug!{"(checking coherence) item '%s'", *item.ident}; alt item.node { item_impl(_, associated_traits, _, _) { @@ -199,9 +199,9 @@ class CoherenceChecker { // base type. if associated_traits.len() == 0 { - #debug("(checking implementation) no associated traits for item \ + debug!{"(checking implementation) no associated traits for item \ '%s'", - *item.ident); + *item.ident}; alt get_base_type_def_id(self.inference_context, item.span, @@ -222,11 +222,11 @@ class CoherenceChecker { for associated_traits.each |associated_trait| { let def = self.crate_context.tcx.def_map.get (associated_trait.ref_id); - #debug("(checking implementation) adding impl for trait \ + debug!{"(checking implementation) adding impl for trait \ '%s', item '%s'", ast_map::node_id_to_str(self.crate_context.tcx.items, associated_trait.ref_id), - *item.ident); + *item.ident}; let implementation = self.create_impl_from_item(item); self.add_trait_method(def_id_of_def(def), implementation); @@ -368,10 +368,10 @@ class CoherenceChecker { let privileged_types = self.gather_privileged_types(module.items); for privileged_types.each |privileged_type| { - #debug("(checking privileged scopes) entering \ + debug!{"(checking privileged scopes) entering \ privileged scope of %d:%d", privileged_type.crate, - privileged_type.node); + privileged_type.node}; self.privileged_types.insert(privileged_type, ()); } @@ -584,11 +584,11 @@ class CoherenceChecker { self_type.ty) { none { let session = self.crate_context.tcx.sess; - session.bug(#fmt("no base type for external impl \ + session.bug(fmt!{"no base type for external impl \ with no trait: %s (type %s)!", *implementation.ident, ty_to_str(self.crate_context.tcx, - self_type.ty))); + self_type.ty)}); } some(_) { // Nothing to do. diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index d695101f877..83bc02a3755 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -92,8 +92,8 @@ impl of ast_conv for @crate_ctxt { ty_of_foreign_item(self, foreign_item) } x { - self.tcx.sess.bug(#fmt["unexpected sort of item \ - in get_item_ty(): %?", x]); + self.tcx.sess.bug(fmt!{"unexpected sort of item \ + in get_item_ty(): %?", x}); } } } @@ -194,11 +194,11 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, } if vec::len(impl_m.fty.inputs) != vec::len(if_m.fty.inputs) { - tcx.sess.span_err(sp,#fmt["method `%s` has %u parameters \ + tcx.sess.span_err(sp,fmt!{"method `%s` has %u parameters \ but the trait has %u", *if_m.ident, vec::len(impl_m.fty.inputs), - vec::len(if_m.fty.inputs)]); + vec::len(if_m.fty.inputs)}); ret; } @@ -258,9 +258,9 @@ fn check_methods_against_trait(ccx: @crate_ctxt, some({mty: m, id, span}) { if m.purity != if_m.purity { ccx.tcx.sess.span_err( - span, #fmt["method `%s`'s purity does \ + span, fmt!{"method `%s`'s purity does \ not match the trait method's \ - purity", *m.ident]); + purity", *m.ident}); } compare_impl_method( ccx.tcx, span, m, vec::len(tps), @@ -272,7 +272,7 @@ fn check_methods_against_trait(ccx: @crate_ctxt, tcx.sess.span_err( a_trait_ty.path.span, - #fmt["missing method `%s`", *if_m.ident]); + fmt!{"missing method `%s`", *if_m.ident}); } } // alt } // |if_m| @@ -316,7 +316,7 @@ fn convert_methods(ccx: @crate_ctxt, fn convert(ccx: @crate_ctxt, it: @ast::item) { let tcx = ccx.tcx; let rp = tcx.region_paramd_items.contains_key(it.id); - #debug["convert: item %s with id %d rp %b", *it.ident, it.id, rp]; + debug!{"convert: item %s with id %d rp %b", *it.ident, it.id, rp}; alt it.node { // These don't define types. ast::item_foreign_mod(_) | ast::item_mod(_) {} @@ -341,8 +341,8 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) { } ast::item_trait(*) { let tpt = ty_of_item(ccx, it); - #debug["item_trait(it.id=%d, tpt.ty=%s)", - it.id, ty_to_str(tcx, tpt.ty)]; + debug!{"item_trait(it.id=%d, tpt.ty=%s)", + it.id, ty_to_str(tcx, tpt.ty)}; write_ty_to_tcx(tcx, it.id, tpt.ty); ensure_trait_methods(ccx, it.id); } @@ -501,8 +501,8 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) let tpt = {bounds: bounds, rp: false, // functions do not have a self ty: ty::mk_fn(ccx.tcx, tofd)}; - #debug["type of %s (id %d) is %s", - *it.ident, it.id, ty_to_str(tcx, tpt.ty)]; + debug!{"type of %s (id %d) is %s", + *it.ident, it.id, ty_to_str(tcx, tpt.ty)}; ccx.tcx.tcache.insert(local_def(it.id), tpt); ret tpt; } diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index 77b7f5cec3b..e3075ff0058 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -231,7 +231,7 @@ fn intersection(a: int_ty_set, b: int_ty_set) -> int_ty_set { fn single_type_contained_in(tcx: ty::ctxt, a: int_ty_set) -> option<ty::t> { - #debug["single_type_contained_in(a=%s)", uint::to_str(*a, 10u)]; + debug!{"single_type_contained_in(a=%s)", uint::to_str(*a, 10u)}; if *a == INT_TY_SET_i8 { ret some(ty::mk_i8(tcx)); } if *a == INT_TY_SET_u8 { ret some(ty::mk_u8(tcx)); } @@ -345,8 +345,8 @@ fn fixup_err_to_str(f: fixup_err) -> ~str { cyclic_ty(_) { ~"cyclic type of infinite size" } unresolved_region(_) { ~"unconstrained region" } region_var_bound_by_region_var(r1, r2) { - #fmt["region var %? bound by another region var %?; this is \ - a bug in rustc", r1, r2] + fmt!{"region var %? bound by another region var %?; this is \ + a bug in rustc", r1, r2} } } } @@ -365,29 +365,29 @@ fn new_infer_ctxt(tcx: ty::ctxt) -> infer_ctxt { borrowings: dvec()})} fn mk_subty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures { - #debug["mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)]; + debug!{"mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)}; indent(|| cx.commit(|| sub(cx).tys(a, b) ) ).to_ures() } fn can_mk_subty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures { - #debug["can_mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)]; + debug!{"can_mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)}; indent(|| cx.probe(|| sub(cx).tys(a, b) ) ).to_ures() } fn mk_subr(cx: infer_ctxt, a: ty::region, b: ty::region) -> ures { - #debug["mk_subr(%s <: %s)", a.to_str(cx), b.to_str(cx)]; + debug!{"mk_subr(%s <: %s)", a.to_str(cx), b.to_str(cx)}; indent(|| cx.commit(|| sub(cx).regions(a, b) ) ).to_ures() } fn mk_eqty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures { - #debug["mk_eqty(%s <: %s)", a.to_str(cx), b.to_str(cx)]; + debug!{"mk_eqty(%s <: %s)", a.to_str(cx), b.to_str(cx)}; indent(|| cx.commit(|| cx.eq_tys(a, b) ) ).to_ures() } fn mk_assignty(cx: infer_ctxt, anmnt: assignment, a: ty::t, b: ty::t) -> ures { - #debug["mk_assignty(%? / %s <: %s)", - anmnt, a.to_str(cx), b.to_str(cx)]; + debug!{"mk_assignty(%? / %s <: %s)", + anmnt, a.to_str(cx), b.to_str(cx)}; indent(|| cx.commit(|| cx.assign_tys(anmnt, a, b) ) ).to_ures() @@ -395,8 +395,8 @@ fn mk_assignty(cx: infer_ctxt, anmnt: assignment, fn can_mk_assignty(cx: infer_ctxt, anmnt: assignment, a: ty::t, b: ty::t) -> ures { - #debug["can_mk_assignty(%? / %s <: %s)", - anmnt, a.to_str(cx), b.to_str(cx)]; + debug!{"can_mk_assignty(%? / %s <: %s)", + anmnt, a.to_str(cx), b.to_str(cx)}; // FIXME(#2593)---this will not unroll any entries we make in the // borrowings table. But this is OK for the moment because this @@ -424,8 +424,8 @@ fn resolve_borrowings(cx: infer_ctxt) { for cx.borrowings.each |item| { alt resolve_region(cx, item.scope, resolve_all|force_all) { ok(region) => { - #debug["borrowing for expr %d resolved to region %?, mutbl %?", - item.expr_id, region, item.mutbl]; + debug!{"borrowing for expr %d resolved to region %?, mutbl %?", + item.expr_id, region, item.mutbl}; cx.tcx.borrowings.insert( item.expr_id, {region: region, mutbl: item.mutbl}); } @@ -434,7 +434,7 @@ fn resolve_borrowings(cx: infer_ctxt) { let str = fixup_err_to_str(e); cx.tcx.sess.span_err( item.span, - #fmt["could not resolve lifetime for borrow: %s", str]); + fmt!{"could not resolve lifetime for borrow: %s", str}); } } } @@ -509,9 +509,9 @@ impl<V:copy to_str> of to_str for bound<V> { impl<T:copy to_str> of to_str for bounds<T> { fn to_str(cx: infer_ctxt) -> ~str { - #fmt["{%s <: %s}", + fmt!{"{%s <: %s}", self.lb.to_str(cx), - self.ub.to_str(cx)] + self.ub.to_str(cx)} } } @@ -526,9 +526,9 @@ 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 { alt self { - redirect(vid) { #fmt("redirect(%s)", vid.to_str()) } - root(pt, rk) { #fmt("root(%s, %s)", pt.to_str(cx), - uint::to_str(rk, 10u)) } + redirect(vid) { fmt!{"redirect(%s)", vid.to_str()} } + root(pt, rk) { fmt!{"root(%s, %s)", pt.to_str(cx), + uint::to_str(rk, 10u)} } } } } @@ -604,12 +604,12 @@ impl transaction_methods for infer_ctxt { let rbl = self.rb.bindings.len(); let bl = self.borrowings.len(); - #debug["try(tvbl=%u, rbl=%u)", tvbl, rbl]; + debug!{"try(tvbl=%u, rbl=%u)", tvbl, rbl}; let r <- f(); alt r { - result::ok(_) { #debug["try--ok"]; } + result::ok(_) { debug!{"try--ok"}; } result::err(_) { - #debug["try--rollback"]; + debug!{"try--rollback"}; rollback_to(self.tvb, tvbl); rollback_to(self.rb, rbl); while self.borrowings.len() != bl { self.borrowings.pop(); } @@ -709,8 +709,8 @@ impl unify_methods for infer_ctxt { vec::push(vb.bindings, (vid, old_v)); vb.vals.insert(vid.to_uint(), new_v); - #debug["Updating variable %s from %s to %s", - vid.to_str(), old_v.to_str(self), new_v.to_str(self)]; + debug!{"Updating variable %s from %s to %s", + vid.to_str(), old_v.to_str(self), new_v.to_str(self)}; } fn get<V:copy vid, T:copy>( @@ -720,7 +720,7 @@ impl unify_methods for infer_ctxt { let vid_u = vid.to_uint(); alt vb.vals.find(vid_u) { none { - self.tcx.sess.bug(#fmt["failed lookup of vid `%u`", vid_u]); + self.tcx.sess.bug(fmt!{"failed lookup of vid `%u`", vid_u}); } some(var_val) { alt var_val { @@ -745,7 +745,7 @@ impl unify_methods for infer_ctxt { a: bound<V>, b: bound<V>, merge_op: fn(V,V) -> cres<V>) -> cres<bound<V>> { - #debug["merge_bnd(%s,%s)", a.to_str(self), b.to_str(self)]; + debug!{"merge_bnd(%s,%s)", a.to_str(self), b.to_str(self)}; let _r = indenter(); alt (a, b) { @@ -773,13 +773,13 @@ impl unify_methods for infer_ctxt { let _r = indenter(); do self.merge_bnd(a.ub, b.ub, glb).chain |ub| { - #debug["glb of ubs %s and %s is %s", + debug!{"glb of ubs %s and %s is %s", a.ub.to_str(self), b.ub.to_str(self), - ub.to_str(self)]; + ub.to_str(self)}; do self.merge_bnd(a.lb, b.lb, lub).chain |lb| { - #debug["lub of lbs %s and %s is %s", + debug!{"lub of lbs %s and %s is %s", a.lb.to_str(self), b.lb.to_str(self), - lb.to_str(self)]; + lb.to_str(self)}; ok({lb: lb, ub: ub}) } } @@ -813,10 +813,10 @@ impl unify_methods for infer_ctxt { // A \ / A // B - #debug["merge(%s,%s,%s)", + debug!{"merge(%s,%s,%s)", v_id.to_str(), a.to_str(self), - b.to_str(self)]; + b.to_str(self)}; // First, relate the lower/upper bounds of A and B. // Note that these relations *must* hold for us to @@ -830,9 +830,9 @@ impl unify_methods for infer_ctxt { do self.merge_bnd(a.ub, b.ub, |x, y| x.glb(self, y) ).chain |ub| { do self.merge_bnd(a.lb, b.lb, |x, y| x.lub(self, y) ).chain |lb| { let bnds = {lb: lb, ub: ub}; - #debug["merge(%s): bnds=%s", + debug!{"merge(%s): bnds=%s", v_id.to_str(), - bnds.to_str(self)]; + bnds.to_str(self)}; // the new bounds must themselves // be relatable: @@ -855,9 +855,9 @@ impl unify_methods for infer_ctxt { let a_bounds = nde_a.possible_types; let b_bounds = nde_b.possible_types; - #debug["vars(%s=%s <: %s=%s)", + debug!{"vars(%s=%s <: %s=%s)", a_id.to_str(), a_bounds.to_str(self), - b_id.to_str(), b_bounds.to_str(self)]; + b_id.to_str(), b_bounds.to_str(self)}; if a_id == b_id { ret uok(); } @@ -883,20 +883,20 @@ impl unify_methods for infer_ctxt { // Make the node with greater rank the parent of the node with // smaller rank. if nde_a.rank > nde_b.rank { - #debug["vars(): a has smaller rank"]; + debug!{"vars(): a has smaller rank"}; // a has greater rank, so a should become b's parent, // i.e., b should redirect to a. self.set(vb, b_id, redirect(a_id)); self.set_var_to_merged_bounds( vb, a_id, a_bounds, b_bounds, nde_a.rank).then(|| uok() ) } else if nde_a.rank < nde_b.rank { - #debug["vars(): b has smaller rank"]; + debug!{"vars(): b has smaller rank"}; // b has greater rank, so a should redirect to b. self.set(vb, a_id, redirect(b_id)); self.set_var_to_merged_bounds( vb, b_id, a_bounds, b_bounds, nde_b.rank).then(|| uok() ) } else { - #debug["vars(): a and b have equal rank"]; + debug!{"vars(): a and b have equal rank"}; assert nde_a.rank == nde_b.rank; // If equal, just redirect one to the other and increment // the other's rank. We choose arbitrarily to redirect b @@ -932,18 +932,18 @@ impl unify_methods for infer_ctxt { // Rank optimization if nde_a.rank > nde_b.rank { - #debug["vars_integral(): a has smaller rank"]; + debug!{"vars_integral(): a has smaller rank"}; // a has greater rank, so a should become b's parent, // i.e., b should redirect to a. self.set(vb, a_id, root(intersection, nde_a.rank)); self.set(vb, b_id, redirect(a_id)); } else if nde_a.rank < nde_b.rank { - #debug["vars_integral(): b has smaller rank"]; + debug!{"vars_integral(): b has smaller rank"}; // b has greater rank, so a should redirect to b. self.set(vb, b_id, root(intersection, nde_b.rank)); self.set(vb, a_id, redirect(b_id)); } else { - #debug["vars_integral(): a and b have equal rank"]; + debug!{"vars_integral(): a and b have equal rank"}; assert nde_a.rank == nde_b.rank; // If equal, just redirect one to the other and increment // the other's rank. We choose arbitrarily to redirect b @@ -963,9 +963,9 @@ impl unify_methods for infer_ctxt { let a_id = nde_a.root; let a_bounds = nde_a.possible_types; - #debug["vart(%s=%s <: %s)", + debug!{"vart(%s=%s <: %s)", a_id.to_str(), a_bounds.to_str(self), - b.to_str(self)]; + b.to_str(self)}; let b_bounds = {lb: none, ub: some(b)}; self.set_var_to_merged_bounds(vb, a_id, a_bounds, b_bounds, nde_a.rank) @@ -1000,9 +1000,9 @@ impl unify_methods for infer_ctxt { let b_id = nde_b.root; let b_bounds = nde_b.possible_types; - #debug["tvar(%s <: %s=%s)", + debug!{"tvar(%s <: %s=%s)", a.to_str(self), - b_id.to_str(), b_bounds.to_str(self)]; + b_id.to_str(), b_bounds.to_str(self)}; self.set_var_to_merged_bounds(vb, b_id, a_bounds, b_bounds, nde_b.rank) } @@ -1030,7 +1030,7 @@ impl unify_methods for infer_ctxt { fn bnds<T:copy to_str st>( a: bound<T>, b: bound<T>) -> ures { - #debug("bnds(%s <: %s)", a.to_str(self), b.to_str(self)); + debug!{"bnds(%s <: %s)", a.to_str(self), b.to_str(self)}; do indent { alt (a, b) { (none, none) | @@ -1060,8 +1060,8 @@ impl unify_methods for infer_ctxt { } fn eq_regions(a: ty::region, b: ty::region) -> ures { - #debug["eq_regions(%s, %s)", - a.to_str(self), b.to_str(self)]; + debug!{"eq_regions(%s, %s)", + a.to_str(self), b.to_str(self)}; do indent { do self.sub_regions(a, b).then { self.sub_regions(b, a) @@ -1141,9 +1141,9 @@ impl methods for resolve_state { fn resolve_type_chk(typ: ty::t) -> fres<ty::t> { self.err = none; - #debug["Resolving %s (modes=%x)", + debug!{"Resolving %s (modes=%x)", ty_to_str(self.infcx.tcx, typ), - self.modes]; + self.modes}; // n.b. This is a hokey mess because the current fold doesn't // allow us to pass back errors in any useful way. @@ -1153,9 +1153,9 @@ impl methods for resolve_state { assert vec::is_empty(self.v_seen); alt self.err { none { - #debug["Resolved to %s (modes=%x)", + debug!{"Resolved to %s (modes=%x)", ty_to_str(self.infcx.tcx, rty), - self.modes]; + self.modes}; ret ok(rty); } some(e) { ret err(e); } @@ -1172,7 +1172,7 @@ impl methods for resolve_state { } fn resolve_type(typ: ty::t) -> ty::t { - #debug("resolve_type(%s)", typ.to_str(self.infcx)); + debug!{"resolve_type(%s)", typ.to_str(self.infcx)}; indent(fn&() -> ty::t { if !ty::type_needs_infer(typ) { ret typ; } @@ -1201,7 +1201,7 @@ impl methods for resolve_state { } fn resolve_nested_tvar(typ: ty::t) -> ty::t { - #debug("Resolve_if_deep(%s)", typ.to_str(self.infcx)); + debug!{"Resolve_if_deep(%s)", typ.to_str(self.infcx)}; if !self.should(resolve_nested_tvar) { typ } else { @@ -1210,7 +1210,7 @@ impl methods for resolve_state { } fn resolve_region(orig: ty::region) -> ty::region { - #debug("Resolve_region(%s)", orig.to_str(self.infcx)); + debug!{"Resolve_region(%s)", orig.to_str(self.infcx)}; alt orig { ty::re_var(rid) { self.resolve_region_var(rid) } _ { orig } @@ -1372,8 +1372,8 @@ impl assignment for infer_ctxt { } } - #debug["assign_tys(anmnt=%?, %s -> %s)", - anmnt, a.to_str(self), b.to_str(self)]; + debug!{"assign_tys(anmnt=%?, %s -> %s)", + anmnt, a.to_str(self), b.to_str(self)}; let _r = indenter(); alt (ty::get(a).struct, ty::get(b).struct) { @@ -1419,9 +1419,9 @@ impl assignment for infer_ctxt { a: ty::t, b: ty::t, a_bnd: option<ty::t>, b_bnd: option<ty::t>) -> ures { - #debug["assign_tys_or_sub(anmnt=%?, %s -> %s, %s -> %s)", + debug!{"assign_tys_or_sub(anmnt=%?, %s -> %s, %s -> %s)", anmnt, a.to_str(self), b.to_str(self), - a_bnd.to_str(self), b_bnd.to_str(self)]; + a_bnd.to_str(self), b_bnd.to_str(self)}; let _r = indenter(); fn is_borrowable(v: ty::vstore) -> bool { @@ -1475,9 +1475,9 @@ impl assignment for infer_ctxt { m: ast::mutability, r_b: ty::region) -> ures { - #debug["crosspollinate(anmnt=%?, a=%s, nr_b=%s, r_b=%s)", + debug!{"crosspollinate(anmnt=%?, a=%s, nr_b=%s, r_b=%s)", anmnt, a.to_str(self), nr_b.to_str(self), - r_b.to_str(self)]; + r_b.to_str(self)}; do indent { do self.sub_tys(a, nr_b).then { @@ -1485,12 +1485,12 @@ impl assignment for infer_ctxt { // borrow bounds: let r_a = self.next_region_var_with_scope_lb(anmnt.borrow_lb); - #debug["anmnt=%?", anmnt]; + debug!{"anmnt=%?", anmnt}; do sub(self).contraregions(r_a, r_b).chain |_r| { // if successful, add an entry indicating that // borrowing occurred - #debug["borrowing expression #%?, scope=%?, m=%?", - anmnt, r_a, m]; + debug!{"borrowing expression #%?, scope=%?, m=%?", + anmnt, r_a, m}; self.borrowings.push({expr_id: anmnt.expr_id, span: anmnt.span, scope: r_a, @@ -1596,10 +1596,10 @@ fn super_substs<C:combine>( // consistently have a region parameter or not have a // region parameter. infcx.tcx.sess.bug( - #fmt["substitution a had opt_region %s and \ + fmt!{"substitution a had opt_region %s and \ b had opt_region %s", a.to_str(infcx), - b.to_str(infcx)]); + b.to_str(infcx)}); } } } @@ -1751,10 +1751,10 @@ fn super_tys<C:combine>( (ty::ty_var(_), _) | (_, ty::ty_var(_)) { tcx.sess.bug( - #fmt["%s: bot and var types should have been handled (%s,%s)", + fmt!{"%s: bot and var types should have been handled (%s,%s)", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())]); + b.to_str(self.infcx())}); } // Have to handle these first @@ -1904,10 +1904,10 @@ impl of combine for sub { } fn regions(a: ty::region, b: ty::region) -> cres<ty::region> { - #debug["%s.regions(%s, %s)", + debug!{"%s.regions(%s, %s)", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())]; + b.to_str(self.infcx())}; do indent { alt (a, b) { (ty::re_var(a_id), ty::re_var(b_id)) { @@ -1935,7 +1935,7 @@ impl of combine for sub { } fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt> { - #debug("mts(%s <: %s)", a.to_str(*self), b.to_str(*self)); + debug!{"mts(%s <: %s)", a.to_str(*self), b.to_str(*self)}; if a.mutbl != b.mutbl && b.mutbl != m_const { ret err(ty::terr_mutability); @@ -1973,8 +1973,8 @@ impl of combine for sub { } fn tys(a: ty::t, b: ty::t) -> cres<ty::t> { - #debug("%s.tys(%s, %s)", self.tag(), - a.to_str(*self), b.to_str(*self)); + debug!{"%s.tys(%s, %s)", self.tag(), + a.to_str(*self), b.to_str(*self)}; if a == b { ret ok(a); } do indent { alt (ty::get(a).struct, ty::get(b).struct) { @@ -2015,9 +2015,9 @@ impl of combine for sub { // for it. The only thing we're doing with `br` here is // using it in the debug message. let rvar = self.infcx().next_region_var_nb(); - #debug["Bound region %s maps to %s", + debug!{"Bound region %s maps to %s", bound_region_to_str(self.tcx, br), - region_to_str(self.tcx, rvar)]; + region_to_str(self.tcx, rvar)}; rvar } }; @@ -2078,10 +2078,10 @@ impl of combine for lub { fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt> { let tcx = self.infcx().tcx; - #debug("%s.mts(%s, %s)", + debug!{"%s.mts(%s, %s)", self.tag(), mt_to_str(tcx, a), - mt_to_str(tcx, b)); + mt_to_str(tcx, b)}; let m = if a.mutbl == b.mutbl { a.mutbl @@ -2150,10 +2150,10 @@ impl of combine for lub { } fn regions(a: ty::region, b: ty::region) -> cres<ty::region> { - #debug["%s.regions(%?, %?)", + debug!{"%s.regions(%?, %?)", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())]; + b.to_str(self.infcx())}; do indent { alt (a, b) { @@ -2259,10 +2259,10 @@ impl of combine for glb { fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt> { let tcx = self.infcx().tcx; - #debug("%s.mts(%s, %s)", + debug!{"%s.mts(%s, %s)", self.tag(), mt_to_str(tcx, a), - mt_to_str(tcx, b)); + mt_to_str(tcx, b)}; alt (a.mutbl, b.mutbl) { // If one side or both is mut, then the GLB must use @@ -2347,10 +2347,10 @@ impl of combine for glb { } fn regions(a: ty::region, b: ty::region) -> cres<ty::region> { - #debug["%s.regions(%?, %?)", + debug!{"%s.regions(%?, %?)", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())]; + b.to_str(self.infcx())}; do indent { alt (a, b) { @@ -2486,9 +2486,9 @@ impl of lattice_ops for glb { fn lattice_tys<L:lattice_ops combine>( self: L, a: ty::t, b: ty::t) -> cres<ty::t> { - #debug("%s.lattice_tys(%s, %s)", self.tag(), + debug!{"%s.lattice_tys(%s, %s)", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())); + b.to_str(self.infcx())}; if a == b { ret ok(a); } do indent { alt (ty::get(a).struct, ty::get(b).struct) { @@ -2536,11 +2536,11 @@ fn lattice_rvars<L:lattice_ops combine>( _ { self.infcx().tcx.sess.bug( - #fmt["%s: lattice_rvars invoked with a=%s and b=%s, \ + fmt!{"%s: lattice_rvars invoked with a=%s and b=%s, \ neither of which are region variables", self.tag(), a.to_str(self.infcx()), - b.to_str(self.infcx())]); + b.to_str(self.infcx())}); } } } @@ -2562,10 +2562,10 @@ fn lattice_vars<V:copy vid, T:copy to_str st, L:lattice_ops combine>( let a_bounds = nde_a.possible_types; let b_bounds = nde_b.possible_types; - #debug["%s.lattice_vars(%s=%s <: %s=%s)", + debug!{"%s.lattice_vars(%s=%s <: %s=%s)", self.tag(), a_vid.to_str(), a_bounds.to_str(self.infcx()), - b_vid.to_str(), b_bounds.to_str(self.infcx())]; + b_vid.to_str(), b_bounds.to_str(self.infcx())}; if a_vid == b_vid { ret ok(a_t); @@ -2601,21 +2601,21 @@ fn lattice_var_t<V:copy vid, T:copy to_str st, L:lattice_ops combine>( // The comments in this function are written for LUB, but they // apply equally well to GLB if you inverse upper/lower/sub/super/etc. - #debug["%s.lattice_vart(%s=%s <: %s)", + debug!{"%s.lattice_vart(%s=%s <: %s)", self.tag(), a_id.to_str(), a_bounds.to_str(self.infcx()), - b.to_str(self.infcx())]; + b.to_str(self.infcx())}; alt self.bnd(a_bounds) { some(a_bnd) { // If a has an upper bound, return the LUB(a.ub, b) - #debug["bnd=some(%s)", a_bnd.to_str(self.infcx())]; + debug!{"bnd=some(%s)", a_bnd.to_str(self.infcx())}; ret c_ts(a_bnd, b); } none { // If a does not have an upper bound, make b the upper bound of a // and then return b. - #debug["bnd=none"]; + debug!{"bnd=none"}; let a_bounds = self.with_bnd(a_bounds, b); do self.infcx().bnds(a_bounds.lb, a_bounds.ub).then { self.infcx().set(vb, a_id, root(a_bounds, diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs index 011b482f577..b9f4d3d76ae 100644 --- a/src/rustc/util/common.rs +++ b/src/rustc/util/common.rs @@ -8,20 +8,20 @@ import syntax::print; fn indent<R>(op: fn() -> R) -> R { // Use in conjunction with the log post-processor like `src/etc/indenter` // to make debug output more readable. - #debug[">>"]; + debug!{">>"}; let r <- op(); - #debug["<< (Result = %?)", r]; + debug!{"<< (Result = %?)", r}; ret r; } class _indenter { let _i: (); new(_i: ()) { self._i = (); } - drop { #debug["<<"]; } + drop { debug!{"<<"}; } } fn indenter() -> _indenter { - #debug[">>"]; + debug!{">>"}; _indenter(()) } diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs index d3c05ea6bec..bf97df5fd5f 100644 --- a/src/rustc/util/ppaux.rs +++ b/src/rustc/util/ppaux.rs @@ -22,7 +22,7 @@ import driver::session::session; fn bound_region_to_str(cx: ctxt, br: bound_region) -> ~str { alt br { br_anon => { ~"&" } - br_named(str) => { #fmt["&%s", *str] } + br_named(str) => { fmt!{"&%s", *str} } br_self if cx.sess.ppregions() => { ~"&<self>" } br_self => { ~"&self" } @@ -30,7 +30,7 @@ fn bound_region_to_str(cx: ctxt, br: bound_region) -> ~str { // does not fail br_cap_avoid(id, br) => { if cx.sess.ppregions() { - #fmt["br_cap_avoid(%?, %s)", id, bound_region_to_str(cx, *br)] + fmt!{"br_cap_avoid(%?, %s)", id, bound_region_to_str(cx, *br)} } else { bound_region_to_str(cx, *br) } @@ -41,50 +41,50 @@ fn bound_region_to_str(cx: ctxt, br: bound_region) -> ~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>", - codemap::span_to_str(blk.span, cx.sess.codemap)) + fmt!{"<block at %s>", + codemap::span_to_str(blk.span, cx.sess.codemap)} } some(ast_map::node_expr(expr)) { alt expr.node { ast::expr_call(*) { - #fmt("<call at %s>", - codemap::span_to_str(expr.span, cx.sess.codemap)) + fmt!{"<call at %s>", + codemap::span_to_str(expr.span, cx.sess.codemap)} } ast::expr_alt(*) { - #fmt("<alt at %s>", - codemap::span_to_str(expr.span, cx.sess.codemap)) + fmt!{"<alt at %s>", + codemap::span_to_str(expr.span, cx.sess.codemap)} } ast::expr_assign_op(*) | ast::expr_field(*) | ast::expr_unary(*) | ast::expr_binary(*) | ast::expr_index(*) { - #fmt("<method at %s>", - codemap::span_to_str(expr.span, cx.sess.codemap)) + fmt!{"<method at %s>", + codemap::span_to_str(expr.span, cx.sess.codemap)} } _ { - #fmt("<expression at %s>", - codemap::span_to_str(expr.span, cx.sess.codemap)) + fmt!{"<expression at %s>", + codemap::span_to_str(expr.span, cx.sess.codemap)} } } } none { - #fmt["<unknown-%d>", node_id] + fmt!{"<unknown-%d>", node_id} } _ { cx.sess.bug( - #fmt["re_scope refers to %s", - ast_map::node_id_to_str(cx.items, node_id)]) } + fmt!{"re_scope refers to %s", + ast_map::node_id_to_str(cx.items, node_id)}) } } } 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_scope(node_id) { fmt!{"&%s", re_scope_id_to_str(cx, node_id)} } re_bound(br) { bound_region_to_str(cx, br) } re_free(id, br) { if cx.sess.ppregions() { // For debugging, this version is sometimes helpful: - #fmt["{%d} %s", id, bound_region_to_str(cx, br)] + fmt!{"{%d} %s", id, bound_region_to_str(cx, br)} } else { // But this version is what the user expects to see: bound_region_to_str(cx, br) @@ -92,7 +92,7 @@ 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_var(id) { fmt!{"&%s", id.to_str()} } re_static { ~"&static" } } } @@ -108,7 +108,7 @@ fn mt_to_str(cx: ctxt, m: mt) -> ~str { fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> ~str { alt vs { - ty::vstore_fixed(n) { #fmt["%u", n] } + ty::vstore_fixed(n) { fmt!{"%u", n} } ty::vstore_uniq { ~"~" } ty::vstore_box { ~"@" } ty::vstore_slice(r) { region_to_str(cx, r) } @@ -118,9 +118,9 @@ fn vstore_to_str(cx: ctxt, 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)] + fmt!{"%s/%s", ty, vstore_to_str(cx, vs)} } - _ { #fmt["%s%s", vstore_to_str(cx, vs), ty] } + _ { fmt!{"%s%s", vstore_to_str(cx, vs), ty} } } } @@ -243,7 +243,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str { parameterized(cx, base, substs.self_r, substs.tps) } ty_evec(mt, vs) { - vstore_ty_to_str(cx, #fmt["[%s]", mt_to_str(cx, 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 { ~"@?" } @@ -261,15 +261,15 @@ fn parameterized(cx: ctxt, let r_str = alt self_r { none { ~"" } some(r) { - #fmt["/%s", region_to_str(cx, r)] + fmt!{"/%s", region_to_str(cx, r)} } }; 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] + fmt!{"%s%s", base, r_str} } } diff --git a/src/rustdoc/attr_parser.rs b/src/rustdoc/attr_parser.rs index 931df85fa2a..97f6ae2e81f 100644 --- a/src/rustdoc/attr_parser.rs +++ b/src/rustdoc/attr_parser.rs @@ -51,7 +51,7 @@ fn doc_meta( if vec::is_not_empty(doc_metas) { if vec::len(doc_metas) != 1u { - #warn("ignoring %u doc attributes", vec::len(doc_metas) - 1u); + warn!{"ignoring %u doc attributes", vec::len(doc_metas) - 1u}; } some(doc_metas[0]) } else { diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs index f6be9dd7b54..c1af9d8ce16 100644 --- a/src/rustdoc/config.rs +++ b/src/rustdoc/config.rs @@ -62,7 +62,7 @@ fn usage() { println(~"Usage: rustdoc ~[options] <cratefile>\n"); println(~"Options:\n"); for opts().each |opt| { - println(#fmt(" %s", opt.second())); + println(fmt!{" %s", opt.second()}); } println(~""); } @@ -178,7 +178,7 @@ fn parse_output_format(output_format: ~str) -> result<output_format, ~str> { alt output_format { ~"markdown" { result::ok(markdown) } ~"html" { result::ok(pandoc_html) } - _ { result::err(#fmt("unknown output format '%s'", output_format)) } + _ { result::err(fmt!{"unknown output format '%s'", output_format}) } } } @@ -186,7 +186,7 @@ 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) } - _ { result::err(#fmt("unknown output style '%s'", output_style)) } + _ { result::err(fmt!{"unknown output style '%s'", output_style}) } } } @@ -213,7 +213,7 @@ fn maybe_find_pandoc( let pandoc = do vec::find(possible_pandocs) |pandoc| { let output = program_output(pandoc, ~[~"--version"]); - #debug("testing pandoc cmd %s: %?", pandoc, output); + debug!{"testing pandoc cmd %s: %?", pandoc, output}; output.status == 0 }; diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs index b04210f4d31..beed9c27602 100644 --- a/src/rustdoc/markdown_pass.rs +++ b/src/rustdoc/markdown_pass.rs @@ -123,7 +123,7 @@ 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(fmt!{"%% %s", make_title(page)}); ctxt.w.write_line(~""); } @@ -175,7 +175,7 @@ fn write_header(ctxt: ctxt, lvl: hlvl, doc: doc::itemtag) { 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(fmt!{"%s %s", hashes, title}); ctxt.w.write_line(~""); } @@ -233,7 +233,7 @@ fn header_name(doc: doc::itemtag) -> ~str { } trait_part += trait_type; } - #fmt("%s%s for %s", doc.name(), trait_part, self_ty) + fmt!{"%s%s for %s", doc.name(), trait_part, self_ty} } _ { doc.name() @@ -246,7 +246,7 @@ fn header_text(doc: doc::itemtag) -> ~str { } fn header_text_(kind: ~str, name: ~str) -> ~str { - #fmt("%s `%s`", kind, name) + fmt!{"%s `%s`", kind, name} } fn write_crate( @@ -385,10 +385,10 @@ fn write_index(ctxt: ctxt, index: doc::index) { let header = header_text_(entry.kind, entry.name); let id = entry.link; if option::is_some(entry.brief) { - ctxt.w.write_line(#fmt("* [%s](%s) - %s", - header, id, option::get(entry.brief))); + ctxt.w.write_line(fmt!{"* [%s](%s) - %s", + header, id, option::get(entry.brief)}); } else { - ctxt.w.write_line(#fmt("* [%s](%s)", header, id)); + ctxt.w.write_line(fmt!{"* [%s](%s)", header, id}); } } ctxt.w.write_line(~""); @@ -492,7 +492,7 @@ fn write_sig(ctxt: ctxt, sig: option<~str>) { fn code_block_indent(s: ~str) -> ~str { let lines = str::lines_any(s); - let indented = vec::map(lines, |line| #fmt(" %s", line) ); + let indented = vec::map(lines, |line| fmt!{" %s", line} ); str::connect(indented, ~"\n") } @@ -604,10 +604,10 @@ fn write_variant(ctxt: ctxt, doc: doc::variantdoc) { let sig = option::get(doc.sig); alt doc.desc { some(desc) { - ctxt.w.write_line(#fmt("* `%s` - %s", sig, desc)); + ctxt.w.write_line(fmt!{"* `%s` - %s", sig, desc}); } none { - ctxt.w.write_line(#fmt("* `%s`", sig)); + ctxt.w.write_line(fmt!{"* `%s`", sig}); } } } @@ -761,7 +761,7 @@ mod test { fn render(source: ~str) -> ~str { let (srv, doc) = create_doc_srv(source); let markdown = write_markdown_str_srv(srv, doc); - #debug("markdown: %s", markdown); + debug!{"markdown: %s", markdown}; markdown } @@ -774,23 +774,23 @@ mod test { }; let doc = extract::from_srv(srv, ~""); - #debug("doc (extract): %?", doc); + debug!{"doc (extract): %?", doc}; let doc = tystr_pass::mk_pass().f(srv, doc); - #debug("doc (tystr): %?", doc); + debug!{"doc (tystr): %?", doc}; let doc = path_pass::mk_pass().f(srv, doc); - #debug("doc (path): %?", doc); + debug!{"doc (path): %?", doc}; let doc = attr_pass::mk_pass().f(srv, doc); - #debug("doc (attr): %?", doc); + debug!{"doc (attr): %?", doc}; let doc = desc_to_brief_pass::mk_pass().f(srv, doc); - #debug("doc (desc_to_brief): %?", doc); + debug!{"doc (desc_to_brief): %?", doc}; let doc = unindent_pass::mk_pass().f(srv, doc); - #debug("doc (unindent): %?", doc); + debug!{"doc (unindent): %?", doc}; let doc = sectionalize_pass::mk_pass().f(srv, doc); - #debug("doc (trim): %?", doc); + debug!{"doc (trim): %?", doc}; let doc = trim_pass::mk_pass().f(srv, doc); - #debug("doc (sectionalize): %?", doc); + debug!{"doc (sectionalize): %?", doc}; let doc = markdown_index_pass::mk_pass(config).f(srv, doc); - #debug("doc (index): %?", doc); + debug!{"doc (index): %?", doc}; (srv, doc) } } diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs index 64c7ffd6ae8..ffc8092846c 100644 --- a/src/rustdoc/markdown_writer.rs +++ b/src/rustdoc/markdown_writer.rs @@ -90,8 +90,8 @@ fn pandoc_writer( do generic_writer |markdown| { import io::writer_util; - #debug("pandoc cmd: %s", pandoc_cmd); - #debug("pandoc args: %s", str::connect(pandoc_args, ~" ")); + debug!{"pandoc cmd: %s", pandoc_cmd}; + debug!{"pandoc args: %s", str::connect(pandoc_args, ~" ")}; let pipe_in = os::pipe(); let pipe_out = os::pipe(); @@ -123,10 +123,10 @@ fn pandoc_writer( let stderr = comm::recv(stderr_po); let status = run::waitpid(pid); - #debug("pandoc result: %i", status); + debug!{"pandoc result: %i", status}; if status != 0 { - #error("pandoc-out: %s", stdout); - #error("pandoc-err: %s", stderr); + error!{"pandoc-out: %s", stdout}; + error!{"pandoc-err: %s", stderr}; fail ~"pandoc failed"; } } diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs index 7a23dbd9d9d..13a5b03c5a6 100755 --- a/src/rustdoc/rustdoc.rs +++ b/src/rustdoc/rustdoc.rs @@ -33,7 +33,7 @@ fn run_passes( let mut passno = 0; do vec::foldl(doc, passes) |doc, pass| { - log(debug, #fmt("pass #%d", passno)); + log(debug, fmt!{"pass #%d", passno}); passno += 1; log(debug, doc); do time(pass.name) { @@ -110,7 +110,7 @@ fn main(args: ~[~str]) { let config = alt config::parse_config(args) { result::ok(config) { config } result::err(err) { - io::println(#fmt("error: %s", err)); + io::println(fmt!{"error: %s", err}); ret; } }; @@ -122,7 +122,7 @@ 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(); - #info("time: %3.3f s %s", end - start, what); + info!{"time: %3.3f s %s", end - start, what}; ret rv; } diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs index 774106a6fb4..a6bbfae1df6 100644 --- a/src/rustdoc/tystr_pass.rs +++ b/src/rustdoc/tystr_pass.rs @@ -291,12 +291,12 @@ fn fold_type( ident: ident, node: ast::item_ty(ty, params), _ }, _) { - some(#fmt( + some(fmt!{ "type %s%s = %s", *ident, pprust::typarams_to_str(params), pprust::ty_to_str(ty) - )) + }) } _ { fail ~"expected type" } } diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs index 4bd1393a137..43f57c41f88 100644 --- a/src/test/auxiliary/cci_class_4.rs +++ b/src/test/auxiliary/cci_class_4.rs @@ -4,7 +4,7 @@ class cat { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -22,12 +22,12 @@ class cat { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs index d031546c9db..95870b73c4d 100644 --- a/src/test/auxiliary/cci_class_cast.rs +++ b/src/test/auxiliary/cci_class_cast.rs @@ -7,7 +7,7 @@ class cat : to_str { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -25,12 +25,12 @@ class cat : to_str { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/auxiliary/extern-crosscrate-source.rs b/src/test/auxiliary/extern-crosscrate-source.rs index 55d08a0d0f4..bb8dc68d7ac 100644 --- a/src/test/auxiliary/extern-crosscrate-source.rs +++ b/src/test/auxiliary/extern-crosscrate-source.rs @@ -9,7 +9,7 @@ extern mod rustrt { } fn fact(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; rustrt::rust_dbg_call(cb, n) } diff --git a/src/test/auxiliary/issue_2242_b.rs b/src/test/auxiliary/issue_2242_b.rs index 6371e55dde4..9b91918846c 100644 --- a/src/test/auxiliary/issue_2242_b.rs +++ b/src/test/auxiliary/issue_2242_b.rs @@ -5,5 +5,5 @@ use a; import a::to_str; impl of to_str for int { - fn to_str() -> str { #fmt("%?", self) } + fn to_str() -> str { fmt!{"%?", self} } } diff --git a/src/test/auxiliary/issue_2242_c.rs b/src/test/auxiliary/issue_2242_c.rs index 2497be8a42e..7dfcd9e33b0 100644 --- a/src/test/auxiliary/issue_2242_c.rs +++ b/src/test/auxiliary/issue_2242_c.rs @@ -6,5 +6,5 @@ use a; import a::to_str; impl of to_str for bool { - fn to_str() -> str { #fmt("%b", self) } + fn to_str() -> str { fmt!{"%b", self} } } diff --git a/src/test/auxiliary/test_comm.rs b/src/test/auxiliary/test_comm.rs index d47053c4da6..4542a23b854 100644 --- a/src/test/auxiliary/test_comm.rs +++ b/src/test/auxiliary/test_comm.rs @@ -30,10 +30,10 @@ fn port<T: send>() -> port<T> { class port_ptr<T:send> { let po: *rust_port; new(po: *rust_port) { - #debug("in the port_ptr constructor"); + debug!{"in the port_ptr constructor"}; self.po = po; } drop unsafe { - #debug("in the port_ptr destructor"); + debug!{"in the port_ptr destructor"}; do task::unkillable { let yield = 0u; let yieldp = ptr::addr_of(yield); diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 1f55d003bce..0683624d5ff 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -17,12 +17,12 @@ fn main(argv: ~[~str]) { let tests = vec::view(argv, 1, argv.len()); - #bench[shift_push]; - #bench[read_line]; - #bench[str_set]; - #bench[vec_plus]; - #bench[vec_append]; - #bench[vec_push_all]; + bench!{shift_push}; + bench!{read_line}; + bench!{str_set}; + bench!{vec_plus}; + bench!{vec_append}; + bench!{vec_push_all}; } fn maybe_run_test(argv: &[~str], name: ~str, test: fn()) { @@ -39,7 +39,7 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: fn()) { test(); let stop = precise_time_s(); - io::println(#fmt("%s:\t\t%f ms", name, (stop - start) * 1000f)); + io::println(fmt!{"%s:\t\t%f ms", name, (stop - start) * 1000f}); } fn shift_push() { @@ -53,7 +53,7 @@ fn shift_push() { fn read_line() { let path = path::connect( - #env("CFG_SRC_DIR"), + env!{"CFG_SRC_DIR"}, ~"src/test/bench/shootout-k-nucleotide.data" ); diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs index dec0c0b9f22..3a35e0c89ca 100644 --- a/src/test/bench/core-vec-append.rs +++ b/src/test/bench/core-vec-append.rs @@ -48,18 +48,18 @@ fn main(args: ~[~str]) { let rawf = raw as float; let dvecf = dvec as float; - io::stdout().write_str(#fmt("Raw : %? seconds\n", raw)); - io::stdout().write_str(#fmt(" : %f op/sec\n", maxf/rawf)); - io::stdout().write_str(#fmt("\n")); - io::stdout().write_str(#fmt("Dvec : %? seconds\n", dvec)); - io::stdout().write_str(#fmt(" : %f op/sec\n", maxf/dvecf)); - io::stdout().write_str(#fmt("\n")); + io::stdout().write_str(fmt!{"Raw : %? seconds\n", raw}); + io::stdout().write_str(fmt!{" : %f op/sec\n", maxf/rawf}); + io::stdout().write_str(fmt!{"\n"}); + io::stdout().write_str(fmt!{"Dvec : %? seconds\n", dvec}); + io::stdout().write_str(fmt!{" : %f op/sec\n", maxf/dvecf}); + io::stdout().write_str(fmt!{"\n"}); if dvec < raw { - io::stdout().write_str(#fmt("Dvec is %f%% faster than raw\n", - (rawf - dvecf) / rawf * 100.0)); + io::stdout().write_str(fmt!{"Dvec is %f%% faster than raw\n", + (rawf - dvecf) / rawf * 100.0}); } else { - io::stdout().write_str(#fmt("Raw is %f%% faster than dvec\n", - (dvecf - rawf) / dvecf * 100.0)); + io::stdout().write_str(fmt!{"Raw is %f%% faster than dvec\n", + (dvecf - rawf) / dvecf * 100.0}); } } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 3fea95383d5..3e3f69372b4 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -164,7 +164,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { let mut i = 0u; while vec::any(colors, is_gray) { // Do the BFS. - log(info, #fmt("PBFS iteration %?", i)); + log(info, fmt!{"PBFS iteration %?", i}); i += 1u; colors = do colors.mapi() |i, c| { let c : color = c; @@ -234,7 +234,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result { let mut i = 0u; while par::any(colors, is_gray) { // Do the BFS. - log(info, #fmt("PBFS iteration %?", i)); + log(info, fmt!{"PBFS iteration %?", i}); i += 1u; let old_len = colors.len(); @@ -394,8 +394,8 @@ fn main(args: ~[~str]) { let edges = make_edges(scale, 16u); let stop = time::precise_time_s(); - io::stdout().write_line(#fmt("Generated %? edges in %? seconds.", - vec::len(edges), stop - start)); + io::stdout().write_line(fmt!{"Generated %? edges in %? seconds.", + vec::len(edges), stop - start}); let start = time::precise_time_s(); let graph = make_graph(1u << scale, edges); @@ -404,9 +404,9 @@ fn main(args: ~[~str]) { let mut total_edges = 0u; vec::each(graph, |edges| { total_edges += edges.len(); true }); - io::stdout().write_line(#fmt("Generated graph with %? edges in %? seconds.", + io::stdout().write_line(fmt!{"Generated graph with %? edges in %? seconds.", total_edges / 2u, - stop - start)); + stop - start}); let mut total_seq = 0.0; let mut total_par = 0.0; @@ -415,7 +415,7 @@ fn main(args: ~[~str]) { do gen_search_keys(graph, num_keys).map() |root| { io::stdout().write_line(~""); - io::stdout().write_line(#fmt("Search key: %?", root)); + io::stdout().write_line(fmt!{"Search key: %?", root}); if do_sequential { let start = time::precise_time_s(); @@ -425,8 +425,8 @@ fn main(args: ~[~str]) { //total_seq += stop - start; io::stdout().write_line( - #fmt("Sequential BFS completed in %? seconds.", - stop - start)); + fmt!{"Sequential BFS completed in %? seconds.", + stop - start}); if do_validate { let start = time::precise_time_s(); @@ -434,8 +434,8 @@ fn main(args: ~[~str]) { let stop = time::precise_time_s(); io::stdout().write_line( - #fmt("Validation completed in %? seconds.", - stop - start)); + fmt!{"Validation completed in %? seconds.", + stop - start}); } let start = time::precise_time_s(); @@ -445,8 +445,8 @@ fn main(args: ~[~str]) { total_seq += stop - start; io::stdout().write_line( - #fmt("Alternate Sequential BFS completed in %? seconds.", - stop - start)); + fmt!{"Alternate Sequential BFS completed in %? seconds.", + stop - start}); if do_validate { let start = time::precise_time_s(); @@ -454,8 +454,8 @@ fn main(args: ~[~str]) { let stop = time::precise_time_s(); io::stdout().write_line( - #fmt("Validation completed in %? seconds.", - stop - start)); + fmt!{"Validation completed in %? seconds.", + stop - start}); } } @@ -465,21 +465,21 @@ fn main(args: ~[~str]) { total_par += stop - start; - io::stdout().write_line(#fmt("Parallel BFS completed in %? seconds.", - stop - start)); + io::stdout().write_line(fmt!{"Parallel BFS completed in %? seconds.", + stop - start}); if do_validate { let start = time::precise_time_s(); assert(validate(edges, root, bfs_tree)); let stop = time::precise_time_s(); - io::stdout().write_line(#fmt("Validation completed in %? seconds.", - stop - start)); + io::stdout().write_line(fmt!{"Validation completed in %? seconds.", + stop - start}); } }; 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)); + 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 e6fe83e4499..fdf218a82df 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -34,7 +34,7 @@ fn server(requests: port<request>, responses: pipes::chan<uint>) { alt requests.try_recv() { some(get_count) { responses.send(copy count); } some(bytes(b)) { - //#error("server: received %? bytes", b); + //error!{"server: received %? bytes", b}; count += b; } none { done = true; } @@ -42,7 +42,7 @@ fn server(requests: port<request>, responses: pipes::chan<uint>) { } } responses.send(count); - //#error("server exiting"); + //error!{"server exiting"}; } fn run(args: &[~str]) { @@ -62,10 +62,10 @@ fn run(args: &[~str]) { vec::push(worker_results, r); }).spawn { for uint::range(0u, size / workers) |_i| { - //#error("worker %?: sending %? bytes", i, num_bytes); + //error!{"worker %?: sending %? bytes", i, num_bytes}; to_child.send(bytes(num_bytes)); } - //#error("worker %? exiting", i); + //error!{"worker %? exiting", i}; }; } do task::spawn { @@ -73,16 +73,16 @@ fn run(args: &[~str]) { } vec::iter(worker_results, |r| { future::get(r); } ); - //#error("sending stop message"); + //error!{"sending stop message"}; to_child.send(stop); move!{to_child}; let result = from_child.recv(); let end = std::time::precise_time_s(); let elapsed = end - start; - io::stdout().write_str(#fmt("Count is %?\n", result)); - io::stdout().write_str(#fmt("Test took %? seconds\n", elapsed)); + io::stdout().write_str(fmt!{"Count is %?\n", result}); + io::stdout().write_str(fmt!{"Test took %? seconds\n", elapsed}); let thruput = ((size / workers * workers) as float) / (elapsed as float); - io::stdout().write_str(#fmt("Throughput=%f per sec\n", thruput)); + io::stdout().write_str(fmt!{"Throughput=%f per sec\n", thruput}); assert result == num_bytes * size; } @@ -95,6 +95,6 @@ fn main(args: ~[~str]) { copy args }; - #debug("%?", args); + debug!{"%?", args}; run(args); } diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index 83fbba23c44..0428123a00c 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -29,7 +29,7 @@ fn server(requests: port_set<request>, responses: pipes::chan<uint>) { alt requests.try_recv() { some(get_count) { responses.send(copy count); } some(bytes(b)) { - //#error("server: received %? bytes", b); + //error!{"server: received %? bytes", b}; count += b; } none { done = true; } @@ -37,7 +37,7 @@ fn server(requests: port_set<request>, responses: pipes::chan<uint>) { } } responses.send(count); - //#error("server exiting"); + //error!{"server exiting"}; } fn run(args: &[~str]) { @@ -58,10 +58,10 @@ fn run(args: &[~str]) { vec::push(worker_results, r); }).spawn { for uint::range(0u, size / workers) |_i| { - //#error("worker %?: sending %? bytes", i, num_bytes); + //error!{"worker %?: sending %? bytes", i, num_bytes}; to_child.send(bytes(num_bytes)); } - //#error("worker %? exiting", i); + //error!{"worker %? exiting", i}; }; } do task::spawn { @@ -69,16 +69,16 @@ fn run(args: &[~str]) { } vec::iter(worker_results, |r| { future::get(r); } ); - //#error("sending stop message"); + //error!{"sending stop message"}; to_child.send(stop); move!{to_child}; let result = from_child.recv(); let end = std::time::precise_time_s(); let elapsed = end - start; - io::stdout().write_str(#fmt("Count is %?\n", result)); - io::stdout().write_str(#fmt("Test took %? seconds\n", elapsed)); + io::stdout().write_str(fmt!{"Count is %?\n", result}); + io::stdout().write_str(fmt!{"Test took %? seconds\n", elapsed}); let thruput = ((size / workers * workers) as float) / (elapsed as float); - io::stdout().write_str(#fmt("Throughput=%f per sec\n", thruput)); + io::stdout().write_str(fmt!{"Throughput=%f per sec\n", thruput}); assert result == num_bytes * size; } @@ -91,6 +91,6 @@ fn main(args: ~[~str]) { copy args }; - #debug("%?", args); + debug!{"%?", args}; run(args); } diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs index 3e2e955a083..952157cfcaf 100644 --- a/src/test/bench/msgsend-ring-pipes.rs +++ b/src/test/bench/msgsend-ring-pipes.rs @@ -36,7 +36,7 @@ fn thread_ring(i: uint, let mut num_port <- some(num_port); // Send/Receive lots of messages. for uint::range(0u, count) |j| { - //#error("task %?, iter %?", i, j); + //error!{"task %?, iter %?", i, j}; let mut num_chan2 = none; let mut num_port2 = none; num_chan2 <-> num_chan; @@ -46,7 +46,7 @@ fn thread_ring(i: uint, alt recv(port) { ring::num(_n, p) { //log(error, _n); - num_port = some(#move(p)); + num_port = some(move!{p}); } } }; @@ -73,7 +73,7 @@ fn main(args: ~[~str]) { let mut futures = ~[]; for uint::range(1u, num_tasks) |i| { - //#error("spawning %?", i); + //error!{"spawning %?", i}; let (new_chan, num_port) = ring::init(); let num_chan2 = ~mut none; *num_chan2 <-> num_chan; @@ -103,8 +103,8 @@ fn main(args: ~[~str]) { let elapsed = (stop - start); let rate = (num_msgs as float) / elapsed; - io::println(#fmt("Sent %? messages in %? seconds", - num_msgs, elapsed)); - io::println(#fmt(" %? messages / second", rate)); - io::println(#fmt(" %? μs / message", 1000000. / rate)); + io::println(fmt!{"Sent %? messages in %? seconds", + num_msgs, elapsed}); + io::println(fmt!{" %? messages / second", rate}); + io::println(fmt!{" %? μs / message", 1000000. / rate}); } diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs index ceaed45f8f3..6722423a08e 100644 --- a/src/test/bench/msgsend-ring.rs +++ b/src/test/bench/msgsend-ring.rs @@ -68,8 +68,8 @@ fn main(args: ~[~str]) { let elapsed = (stop - start); let rate = (num_msgs as float) / elapsed; - io::println(#fmt("Sent %? messages in %? seconds", - num_msgs, elapsed)); - io::println(#fmt(" %? messages / second", rate)); - io::println(#fmt(" %? μs / message", 1000000. / rate)); + io::println(fmt!{"Sent %? messages in %? seconds", + num_msgs, elapsed}); + io::println(fmt!{" %? messages / second", rate}); + io::println(fmt!{" %? μs / message", 1000000. / rate}); } diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs index a1407374fa0..606f33936c1 100644 --- a/src/test/bench/msgsend.rs +++ b/src/test/bench/msgsend.rs @@ -52,10 +52,10 @@ fn run(args: ~[~str]) { let result = comm::recv(from_child); let end = std::time::precise_time_s(); let elapsed = end - start; - io::stdout().write_str(#fmt("Count is %?\n", result)); - io::stdout().write_str(#fmt("Test took %? seconds\n", elapsed)); + io::stdout().write_str(fmt!{"Count is %?\n", result}); + io::stdout().write_str(fmt!{"Test took %? seconds\n", elapsed}); let thruput = ((size / workers * workers) as float) / (elapsed as float); - io::stdout().write_str(#fmt("Throughput=%f per sec\n", thruput)); + io::stdout().write_str(fmt!{"Throughput=%f per sec\n", thruput}); } fn main(args: ~[~str]) { @@ -67,7 +67,7 @@ fn main(args: ~[~str]) { args }; - #debug("%?", args); + debug!{"%?", args}; run(args); } diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs index d6bd8562285..f9c7d39a259 100644 --- a/src/test/bench/pingpong.rs +++ b/src/test/bench/pingpong.rs @@ -136,13 +136,13 @@ fn main() { let bounded = do timeit { bounded(count) }; let unbounded = do timeit { unbounded(count) }; - io::println(#fmt("count: %?\n", count)); - io::println(#fmt("bounded: %? s\t(%? μs/message)", - bounded, bounded * 1000000. / (count as float))); - io::println(#fmt("unbounded: %? s\t(%? μs/message)", - unbounded, unbounded * 1000000. / (count as float))); + io::println(fmt!{"count: %?\n", count}); + io::println(fmt!{"bounded: %? s\t(%? μs/message)", + bounded, bounded * 1000000. / (count as float)}); + io::println(fmt!{"unbounded: %? s\t(%? μs/message)", + unbounded, unbounded * 1000000. / (count as float)}); - io::println(#fmt("\n\ + io::println(fmt!{"\n\ bounded is %?%% faster", - (unbounded - bounded) / bounded * 100.)); + (unbounded - bounded) / bounded * 100.}); } diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index 21d82f4daf9..f9b698a2195 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -21,5 +21,5 @@ fn main(args: ~[~str]) { args }; let n = int::from_str(args[1]).get(); - io::println(#fmt("Ack(3,%d): %d\n", n, ack(3, n))); + io::println(fmt!{"Ack(3,%d): %d\n", n, ack(3, n)}); } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 5c9fad50378..55e566296fc 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -44,9 +44,9 @@ fn main(args: ~[~str]) { let stretch_depth = max_depth + 1; let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth); - io::println(#fmt("stretch tree of depth %d\t check: %d", + io::println(fmt!{"stretch tree of depth %d\t check: %d", stretch_depth, - item_check(stretch_tree))); + item_check(stretch_tree)}); let long_lived_arena = arena::arena(); let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth); @@ -62,12 +62,12 @@ fn main(args: ~[~str]) { chk += item_check(temp_tree); i += 1; } - io::println(#fmt("%d\t trees of depth %d\t check: %d", + io::println(fmt!{"%d\t trees of depth %d\t check: %d", iterations * 2, depth, - chk)); + chk}); depth += 2; } - io::println(#fmt("long lived trees of depth %d\t check: %d", + io::println(fmt!{"long lived trees of depth %d\t check: %d", max_depth, - item_check(long_lived_tree))); + item_check(long_lived_tree)}); } diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 900df13cf3f..0400e8b127e 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -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; diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs index 0e0a5333c04..4f48c8799b7 100644 --- a/src/test/bench/shootout-fannkuchredux.rs +++ b/src/test/bench/shootout-fannkuchredux.rs @@ -43,7 +43,7 @@ fn fannkuch(n: int) -> int { let mut go = true; while go { if r == n { - io::println(#fmt("%d", checksum)); + io::println(fmt!{"%d", checksum}); ret flips; } let p0 = perm1[0]; @@ -68,5 +68,5 @@ fn main(args: ~[~str]) { }; let n = int::from_str(args[1]).get(); - io::println(#fmt("Pfannkuchen(%d) = %d", n, fannkuch(n))); + io::println(fmt!{"Pfannkuchen(%d) = %d", n, fannkuch(n)}); } diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index 08932324ac2..2851b59956e 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -17,5 +17,5 @@ fn main(args: ~[~str]) { args }; let n = int::from_str(args[1]).get(); - io::println(#fmt("%d\n", fib(n))); + io::println(fmt!{"%d\n", fib(n)}); } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 4d4730afe44..d8a82019f33 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -48,7 +48,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe { let (k,v) = kv; - buffer += (#fmt["%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v]); + buffer += (fmt!{"%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v}); ret true; }); @@ -111,15 +111,15 @@ 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]); + //comm::send(to_parent, fmt!{"yay{%u}", sz}); to_parent.send(buffer); } @@ -129,7 +129,7 @@ fn main(args: ~[~str]) { // 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"), + env!{"CFG_SRC_DIR"}, ~"src/test/bench/shootout-k-nucleotide.data" ); result::get(io::file_reader(path)) diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index dc64f69a06c..2eee8572a77 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -46,7 +46,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe { let (k,v) = kv; - buffer += (#fmt["%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v]); + buffer += (fmt!{"%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v}); ret true; }); @@ -109,15 +109,15 @@ 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]); + //comm::send(to_parent, fmt!{"yay{%u}", sz}); comm::send(to_parent, buffer); } @@ -127,7 +127,7 @@ fn main(args: ~[~str]) { // 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"), + env!{"CFG_SRC_DIR"}, ~"src/test/bench/shootout-k-nucleotide.data" ); result::get(io::file_reader(path)) diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 8a3a9371adb..c752dc4050d 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -117,20 +117,20 @@ fn writer(path: ~str, writech: comm::chan<comm::chan<line>>, size: uint) } }; cout.write_line(~"P4"); - cout.write_line(#fmt("%u %u", size, size)); + cout.write_line(fmt!{"%u %u", size, size}); let lines = std::map::uint_hash(); let mut done = 0_u; let mut i = 0_u; while i < size { let aline = comm::recv(p); if aline.i == done { - #debug("W %u", aline.i); + debug!{"W %u", aline.i}; cout.write(aline.b); done += 1_u; let mut prev = done; while prev <= i { if lines.contains_key(prev) { - #debug("WS %u", prev); + debug!{"WS %u", prev}; // FIXME (#2280): this temporary shouldn't be // necessary, but seems to be, for borrowing. let v : ~[u8] = lines.get(prev); @@ -145,7 +145,7 @@ fn writer(path: ~str, writech: comm::chan<comm::chan<line>>, size: uint) }; } else { - #debug("S %u", aline.i); + debug!{"S %u", aline.i}; lines.insert(aline.i, aline.b); }; i += 1_u; @@ -177,7 +177,7 @@ fn main(args: ~[~str]) { for uint::range(0_u, size) |j| { task::spawn(|| chanmb(j, size, ch) ); if j % yieldevery == 0_u { - #debug("Y %u", j); + debug!{"Y %u", j}; task::yield(); }; }; diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 8c2c4426934..c90ba53c580 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -23,10 +23,10 @@ fn main(args: ~[~str]) { }; let n = int::from_str(args[1]).get(); let bodies: ~[Body::props] = NBodySystem::make(); - io::println(#fmt("%f", NBodySystem::energy(bodies))); + io::println(fmt!{"%f", NBodySystem::energy(bodies)}); let mut i = 0; while i < n { NBodySystem::advance(bodies, 0.01); i += 1; } - io::println(#fmt("%f", NBodySystem::energy(bodies))); + io::println(fmt!{"%f", NBodySystem::energy(bodies)}); } mod NBodySystem { diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index f1e83b58ea3..be7a8c6c3c7 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -64,7 +64,7 @@ fn stress_task(&&id: int) { let n = 15; assert (fib(n) == fib(n)); i += 1; - #error("%d: Completed %d iterations", id, i); + error!{"%d: Completed %d iterations", id, i}; } } @@ -109,8 +109,8 @@ fn main(args: ~[~str]) { let elapsed = stop - start; - out.write_line(#fmt["%d\t%d\t%s", n, fibn, - u64::str(elapsed)]); + out.write_line(fmt!{"%d\t%d\t%s", n, fibn, + u64::str(elapsed)}); } } } diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index 983efce1f50..69f31b39075 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -69,5 +69,5 @@ fn main(args: ~[~str]) { i += 1u; } - io::println(#fmt("%0.9f\n", float::sqrt(vBv / vv))); + io::println(fmt!{"%0.9f\n", float::sqrt(vBv / vv)}); } diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index e064c9481f2..890f36b833c 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -23,11 +23,11 @@ fn roundtrip(id: int, p: comm::port<int>, ch: comm::chan<int>) { while (true) { alt comm::recv(p) { 1 { - io::println(#fmt("%d\n", id)); + io::println(fmt!{"%d\n", id}); ret; } token { - #debug("%d %d", id, token); + debug!{"%d %d", id, token}; comm::send(ch, token - 1); if token <= n_threads { ret; diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 865385d81b0..f5e4ab2e8fa 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -45,8 +45,8 @@ fn main(args: ~[~str]) { let maxf = max as float; - io::stdout().write_str(#fmt("insert(): %? seconds\n", checkf)); - io::stdout().write_str(#fmt(" : %f op/sec\n", maxf/checkf)); - io::stdout().write_str(#fmt("get() : %? seconds\n", appendf)); - io::stdout().write_str(#fmt(" : %f op/sec\n", maxf/appendf)); + io::stdout().write_str(fmt!{"insert(): %? seconds\n", checkf}); + io::stdout().write_str(fmt!{" : %f op/sec\n", maxf/checkf}); + io::stdout().write_str(fmt!{"get() : %? seconds\n", appendf}); + io::stdout().write_str(fmt!{" : %f op/sec\n", maxf/appendf}); } diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index f1bf1ec8d0a..e062e5c9dcb 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -118,9 +118,9 @@ fn solve_grid(g: grid_t) { fn write_grid(f: io::writer, g: grid_t) { for u8::range(0u8, 9u8) |row| { - f.write_str(#fmt("%u", (*g)[row][0] as uint)); + f.write_str(fmt!{"%u", (*g)[row][0] as uint}); for u8::range(1u8, 9u8) |col| { - f.write_str(#fmt(" %u", (*g)[row][col] as uint)); + f.write_str(fmt!{" %u", (*g)[row][col] as uint}); } f.write_char('\n'); } diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index 64959988eb3..e24b7bf5fa4 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -17,11 +17,11 @@ fn main() { fn run(repeat: int, depth: int) { for iter::repeat(repeat as uint) { - #debug("starting %.4f", precise_time_s()); + debug!{"starting %.4f", precise_time_s()}; do task::try { recurse_or_fail(depth, none) }; - #debug("stopping %.4f", precise_time_s()); + debug!{"stopping %.4f", precise_time_s()}; } } @@ -48,7 +48,7 @@ class r { fn recurse_or_fail(depth: int, st: option<st>) { if depth == 0 { - #debug("unwinding %.4f", precise_time_s()); + debug!{"unwinding %.4f", precise_time_s()}; fail; } else { let depth = depth - 1; diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs index adb5e1a0799..8dd6f957ffa 100644 --- a/src/test/bench/task-perf-one-million.rs +++ b/src/test/bench/task-perf-one-million.rs @@ -68,5 +68,5 @@ fn main(args: ~[~str]) { let sum = alt check comm::recv(port) { done(sum) { sum } }; - #error("How many tasks? %d tasks.", sum); + error!{"How many tasks? %d tasks.", sum}; } diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 382ccc1a35a..59e655186ce 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -80,7 +80,7 @@ impl of word_reader for io::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) } + result::err(e) { fail fmt!{"%?", e} } } } @@ -99,7 +99,7 @@ fn reduce(&&word: ~str, get: map_reduce::getter<int>) { loop { alt get() { some(_) { count += 1; } none { break; } } } - io::println(#fmt("%s\t%?", word, count)); + io::println(fmt!{"%s\t%?", word, count}); } class box<T> { @@ -225,11 +225,11 @@ mod map_reduce { while !is_done || ref_count > 0 { alt recv(p) { emit_val(v) { - // #error("received %d", v); + // error!{"received %d", v}; ret some(v); } done { - // #error("all done"); + // error!{"all done"}; is_done = true; } ref { ref_count += 1; } @@ -260,7 +260,7 @@ mod map_reduce { let (_ready, message, ctrls) = pipes::select(ctrl); alt option::unwrap(message) { ctrl_proto::mapper_done { - // #error("received mapper terminated."); + // error!{"received mapper terminated."}; num_mappers -= 1; ctrl = ctrls; } @@ -301,7 +301,7 @@ 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]]); + out.write_line(fmt!{"Usage: %s <filename> ...", argv[0]}); ret; } diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs index 6dcc1fd876d..dd0628d4253 100644 --- a/src/test/bench/task-perf-word-count.rs +++ b/src/test/bench/task-perf-word-count.rs @@ -113,11 +113,11 @@ mod map_reduce { while !state.is_done || state.ref_count > 0 { alt recv(p) { emit_val(v) { - // #error("received %d", v); + // error!{"received %d", v}; ret some(v); } done { - // #error("all done"); + // error!{"all done"}; state.is_done = true; } ref { state.ref_count += 1; } @@ -146,7 +146,7 @@ mod map_reduce { while num_mappers > 0 { alt recv(ctrl) { mapper_done { - // #error("received mapper terminated."); + // error!{"received mapper terminated."}; num_mappers -= 1; } find_reducer(k, cc) { diff --git a/src/test/compile-fail/assign-imm-local-twice.rs b/src/test/compile-fail/assign-imm-local-twice.rs index 54b130ae26f..f0e6e104006 100644 --- a/src/test/compile-fail/assign-imm-local-twice.rs +++ b/src/test/compile-fail/assign-imm-local-twice.rs @@ -1,9 +1,9 @@ fn test() { let v: int; v = 1; //~ NOTE prior assignment occurs here - #debug["v=%d", v]; + debug!{"v=%d", v}; v = 2; //~ ERROR re-assignment of immutable variable - #debug["v=%d", v]; + debug!{"v=%d", v}; } fn main() { diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs index 57bfd8ea103..bd1a17c6b82 100644 --- a/src/test/compile-fail/assign-to-method.rs +++ b/src/test/compile-fail/assign-to-method.rs @@ -11,5 +11,5 @@ class cat { fn main() { let nyan : cat = cat(52u, 99); - nyan.speak = fn@() { #debug["meow"]; }; //~ ERROR attempted to take value of method + nyan.speak = fn@() { debug!{"meow"}; }; //~ ERROR attempted to take value of method } diff --git a/src/test/compile-fail/attr-before-ext.rs b/src/test/compile-fail/attr-before-ext.rs index 2f4b8111bc9..352189722cf 100644 --- a/src/test/compile-fail/attr-before-ext.rs +++ b/src/test/compile-fail/attr-before-ext.rs @@ -1,4 +1,4 @@ fn main() { #[attr] - #debug("hi"); //~ ERROR expected item + debug!{"hi"}; //~ ERROR expected item } \ No newline at end of file diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs index 449f12c2609..e578816c0e3 100644 --- a/src/test/compile-fail/bogus-tag.rs +++ b/src/test/compile-fail/bogus-tag.rs @@ -7,8 +7,8 @@ enum color { rgb(int, int, int), rgba(int, int, int, int), } fn main() { let red: color = rgb(255, 0, 0); alt red { - rgb(r, g, b) { #debug("rgb"); } - hsl(h, s, l) { #debug("hsl"); } + rgb(r, g, b) { debug!{"rgb"}; } + hsl(h, s, l) { debug!{"hsl"}; } } } diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs index 0f5d61b510c..6353a470f9a 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs @@ -7,14 +7,14 @@ fn box_imm() { let _w = &mut v; //~ NOTE loan of mutable local variable granted here do task::spawn |move v| { //~^ ERROR moving out of mutable local variable prohibited due to outstanding loan - #debug["v=%d", *v]; + debug!{"v=%d", *v}; } let mut v = ~3; let _w = &mut v; //~ NOTE loan of mutable local variable granted here task::spawn(fn~(move v) { //~^ ERROR moving out of mutable local variable prohibited due to outstanding loan - #debug["v=%d", *v]; + debug!{"v=%d", *v}; }); } diff --git a/src/test/compile-fail/class-cast-to-iface.rs b/src/test/compile-fail/class-cast-to-iface.rs index e79c021d9f3..72e215688fd 100644 --- a/src/test/compile-fail/class-cast-to-iface.rs +++ b/src/test/compile-fail/class-cast-to-iface.rs @@ -7,7 +7,7 @@ class cat : noisy { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -25,12 +25,12 @@ class cat : noisy { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs index 5e27afaf164..4bad4bd2bc5 100644 --- a/src/test/compile-fail/class-missing-self.rs +++ b/src/test/compile-fail/class-missing-self.rs @@ -3,7 +3,7 @@ class cat { let mut meows : uint; fn sleep() { loop{} } fn meow() { - #error("Meow"); + error!{"Meow"}; meows += 1u; //~ ERROR unresolved name sleep(); //~ ERROR unresolved name } diff --git a/src/test/compile-fail/dead-code-ret.rs b/src/test/compile-fail/dead-code-ret.rs index 3d9ec1dfad3..fe7b7aec104 100644 --- a/src/test/compile-fail/dead-code-ret.rs +++ b/src/test/compile-fail/dead-code-ret.rs @@ -5,5 +5,5 @@ fn f(caller: str) { log(debug, caller); } -fn main() { ret f("main"); #debug("Paul is dead"); } +fn main() { ret f("main"); debug!{"Paul is dead"}; } diff --git a/src/test/compile-fail/does-nothing.rs b/src/test/compile-fail/does-nothing.rs index c861b460e47..b8e724327b0 100644 --- a/src/test/compile-fail/does-nothing.rs +++ b/src/test/compile-fail/does-nothing.rs @@ -1,3 +1,3 @@ // error-pattern: unresolved name: this_does_nothing_what_the -fn main() { #debug("doing"); this_does_nothing_what_the; #debug("boing"); } +fn main() { debug!{"doing"}; this_does_nothing_what_the; debug!{"boing"}; } diff --git a/src/test/compile-fail/export2.rs b/src/test/compile-fail/export2.rs index ab8744e722a..ecef4685fd5 100644 --- a/src/test/compile-fail/export2.rs +++ b/src/test/compile-fail/export2.rs @@ -9,7 +9,7 @@ mod foo { mod bar { export y; - fn x() { #debug("x"); } + fn x() { debug!{"x"}; } fn y() { } } diff --git a/src/test/compile-fail/ext-after-attrib.rs b/src/test/compile-fail/ext-after-attrib.rs index 67efdcd0187..4b43dc21834 100644 --- a/src/test/compile-fail/ext-after-attrib.rs +++ b/src/test/compile-fail/ext-after-attrib.rs @@ -1,7 +1,7 @@ -// error-pattern:expected item but found `#` +// error-pattern:expected item but found `fmt` // Don't know how to deal with a syntax extension appearing after an // item attribute. Probably could use a better error message. #[foo = "bar"] -#fmt("baz") +fmt!{"baz"} fn main() { } \ No newline at end of file diff --git a/src/test/compile-fail/ext-nonexistent.rs b/src/test/compile-fail/ext-nonexistent.rs index ec63c1f07d0..94df92825a2 100644 --- a/src/test/compile-fail/ext-nonexistent.rs +++ b/src/test/compile-fail/ext-nonexistent.rs @@ -1,2 +1,2 @@ // error-pattern:macro undefined -fn main() { #iamnotanextensionthatexists[""]; } +fn main() { iamnotanextensionthatexists!{""}; } diff --git a/src/test/compile-fail/extenv-no-args.rs b/src/test/compile-fail/extenv-no-args.rs index 44611424079..2b28e009b95 100644 --- a/src/test/compile-fail/extenv-no-args.rs +++ b/src/test/compile-fail/extenv-no-args.rs @@ -1,3 +1,3 @@ // error-pattern:#env takes between 1 and 1 arguments -fn main() { #env[]; } +fn main() { env!{}; } diff --git a/src/test/compile-fail/extenv-not-string-literal.rs b/src/test/compile-fail/extenv-not-string-literal.rs index 57d50b2e54d..009da5e38df 100644 --- a/src/test/compile-fail/extenv-not-string-literal.rs +++ b/src/test/compile-fail/extenv-not-string-literal.rs @@ -1,3 +1,3 @@ // error-pattern:requires a string -fn main() { #env[10]; } +fn main() { env!{10}; } diff --git a/src/test/compile-fail/extenv-too-many-args.rs b/src/test/compile-fail/extenv-too-many-args.rs index 6e70b67f9c4..02e6fb2940f 100644 --- a/src/test/compile-fail/extenv-too-many-args.rs +++ b/src/test/compile-fail/extenv-too-many-args.rs @@ -1,3 +1,3 @@ // error-pattern:#env takes between 1 and 1 arguments -fn main() { #env["one", "two"]; } +fn main() { env!{"one", "two"}; } diff --git a/src/test/compile-fail/extfmt-missing-type.rs b/src/test/compile-fail/extfmt-missing-type.rs index 9e1cbc557d4..09330d46aac 100644 --- a/src/test/compile-fail/extfmt-missing-type.rs +++ b/src/test/compile-fail/extfmt-missing-type.rs @@ -1,3 +1,3 @@ // error-pattern:missing type -fn main() { #fmt["%+"]; } +fn main() { fmt!{"%+"}; } diff --git a/src/test/compile-fail/extfmt-no-args.rs b/src/test/compile-fail/extfmt-no-args.rs index f88d74dd166..701e5f56827 100644 --- a/src/test/compile-fail/extfmt-no-args.rs +++ b/src/test/compile-fail/extfmt-no-args.rs @@ -1,3 +1,3 @@ // error-pattern:#fmt needs at least 1 arguments -fn main() { #fmt[]; } +fn main() { fmt!{}; } diff --git a/src/test/compile-fail/extfmt-non-literal.rs b/src/test/compile-fail/extfmt-non-literal.rs index 445455f33d8..ceae0f62a24 100644 --- a/src/test/compile-fail/extfmt-non-literal.rs +++ b/src/test/compile-fail/extfmt-non-literal.rs @@ -4,5 +4,5 @@ fn main() { // #fmt's first argument must be a literal. Hopefully this // restriction can be eased eventually to just require a // compile-time constant. - let x = #fmt["a" + "b"]; + let x = fmt!{"a" + "b"}; } diff --git a/src/test/compile-fail/extfmt-non-literal2.rs b/src/test/compile-fail/extfmt-non-literal2.rs index 8a2d7c4bbed..d325b2dbf7c 100644 --- a/src/test/compile-fail/extfmt-non-literal2.rs +++ b/src/test/compile-fail/extfmt-non-literal2.rs @@ -4,5 +4,5 @@ fn main() { // #fmt's first argument must be a literal. Hopefully this // restriction can be eased eventually to just require a // compile-time constant. - let x = #fmt[20]; + let x = fmt!{20}; } diff --git a/src/test/compile-fail/extfmt-not-enough-args.rs b/src/test/compile-fail/extfmt-not-enough-args.rs index 849a836060d..2804a64c35b 100644 --- a/src/test/compile-fail/extfmt-not-enough-args.rs +++ b/src/test/compile-fail/extfmt-not-enough-args.rs @@ -2,4 +2,4 @@ use std; -fn main() { let s = #fmt["%s%s%s", "test", "test"]; } +fn main() { let s = fmt!{"%s%s%s", "test", "test"}; } diff --git a/src/test/compile-fail/extfmt-too-many-args.rs b/src/test/compile-fail/extfmt-too-many-args.rs index 4c91da227e1..447d84aed80 100644 --- a/src/test/compile-fail/extfmt-too-many-args.rs +++ b/src/test/compile-fail/extfmt-too-many-args.rs @@ -2,4 +2,4 @@ use std; -fn main() { let s = #fmt["%s", "test", "test"]; } +fn main() { let s = fmt!{"%s", "test", "test"}; } diff --git a/src/test/compile-fail/extfmt-unknown-type.rs b/src/test/compile-fail/extfmt-unknown-type.rs index 3a35a1d727b..bfb6c99d351 100644 --- a/src/test/compile-fail/extfmt-unknown-type.rs +++ b/src/test/compile-fail/extfmt-unknown-type.rs @@ -1,3 +1,3 @@ // error-pattern:unknown type -fn main() { #fmt["%w"]; } +fn main() { fmt!{"%w"}; } diff --git a/src/test/compile-fail/extfmt-unsigned-plus.rs b/src/test/compile-fail/extfmt-unsigned-plus.rs index 4ac41efb312..0f3781f0438 100644 --- a/src/test/compile-fail/extfmt-unsigned-plus.rs +++ b/src/test/compile-fail/extfmt-unsigned-plus.rs @@ -2,5 +2,5 @@ fn main() { // Can't use a sign on unsigned conversions - #fmt["%+u", 10u]; + fmt!{"%+u", 10u}; } diff --git a/src/test/compile-fail/extfmt-unsigned-space.rs b/src/test/compile-fail/extfmt-unsigned-space.rs index 6393548eb3d..d847ff43a6a 100644 --- a/src/test/compile-fail/extfmt-unsigned-space.rs +++ b/src/test/compile-fail/extfmt-unsigned-space.rs @@ -2,5 +2,5 @@ fn main() { // Can't use a space on unsigned conversions - #fmt["% u", 10u]; + fmt!{"% u", 10u}; } diff --git a/src/test/compile-fail/extfmt-unterminated-conv.rs b/src/test/compile-fail/extfmt-unterminated-conv.rs index 3b7d0ce1767..cb12f54c789 100644 --- a/src/test/compile-fail/extfmt-unterminated-conv.rs +++ b/src/test/compile-fail/extfmt-unterminated-conv.rs @@ -1,3 +1,3 @@ // error-pattern:unterminated conversion -fn main() { #fmt["%"]; } +fn main() { fmt!{"%"}; } diff --git a/src/test/compile-fail/for-loop-decl.rs b/src/test/compile-fail/for-loop-decl.rs index 2252672f1b5..eb327ff3ea1 100644 --- a/src/test/compile-fail/for-loop-decl.rs +++ b/src/test/compile-fail/for-loop-decl.rs @@ -16,4 +16,4 @@ fn bitv_to_str(enclosing: fn_info, v: ~bitv::bitv) -> str { ret s; } -fn main() { #debug("OK"); } +fn main() { debug!{"OK"}; } diff --git a/src/test/compile-fail/import-glob-0.rs b/src/test/compile-fail/import-glob-0.rs index bde9dd5f19e..a1455ffa1f6 100644 --- a/src/test/compile-fail/import-glob-0.rs +++ b/src/test/compile-fail/import-glob-0.rs @@ -7,10 +7,10 @@ mod module_of_many_things { export f2; export f4; - fn f1() { #debug("f1"); } - fn f2() { #debug("f2"); } - fn f3() { #debug("f3"); } - fn f4() { #debug("f4"); } + fn f1() { debug!{"f1"}; } + fn f2() { debug!{"f2"}; } + fn f3() { debug!{"f3"}; } + fn f4() { debug!{"f4"}; } } diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs index 66be16d28a4..e0f2d3a3c09 100644 --- a/src/test/compile-fail/import-glob-circular.rs +++ b/src/test/compile-fail/import-glob-circular.rs @@ -5,7 +5,7 @@ mod circ1 { export f1; export f2; export common; - fn f1() { #debug("f1"); } + fn f1() { debug!{"f1"}; } fn common() -> uint { ret 0u; } } @@ -14,7 +14,7 @@ mod circ2 { export f1; export f2; export common; - fn f2() { #debug("f2"); } + fn f2() { debug!{"f2"}; } fn common() -> uint { ret 1u; } } diff --git a/src/test/compile-fail/import.rs b/src/test/compile-fail/import.rs index 3d3e326f1f5..582096ab31f 100644 --- a/src/test/compile-fail/import.rs +++ b/src/test/compile-fail/import.rs @@ -3,6 +3,6 @@ import zed::bar; import zed::baz; mod zed { - fn bar() { #debug("bar"); } + fn bar() { debug!{"bar"}; } } fn main(args: ~[str]) { bar(); } diff --git a/src/test/compile-fail/import2.rs b/src/test/compile-fail/import2.rs index d576f66b064..2543db0d059 100644 --- a/src/test/compile-fail/import2.rs +++ b/src/test/compile-fail/import2.rs @@ -2,6 +2,6 @@ import baz::zed::bar; mod baz { } mod zed { - fn bar() { #debug("bar3"); } + fn bar() { debug!{"bar3"}; } } fn main(args: ~[str]) { bar(); } diff --git a/src/test/compile-fail/import3.rs b/src/test/compile-fail/import3.rs index 591ee3afa27..395e5e8b412 100644 --- a/src/test/compile-fail/import3.rs +++ b/src/test/compile-fail/import3.rs @@ -1,4 +1,4 @@ // error-pattern: unresolved import main::bar; -fn main(args: ~[str]) { #debug("foo"); } +fn main(args: ~[str]) { debug!{"foo"}; } diff --git a/src/test/compile-fail/import4.rs b/src/test/compile-fail/import4.rs index cf357e8539c..c3ca71c67aa 100644 --- a/src/test/compile-fail/import4.rs +++ b/src/test/compile-fail/import4.rs @@ -3,4 +3,4 @@ mod a { import foo = b::foo; export foo; } mod b { import foo = a::foo; export foo; } -fn main(args: ~[str]) { #debug("loop"); } +fn main(args: ~[str]) { debug!{"loop"}; } diff --git a/src/test/compile-fail/issue-1448-1.rs b/src/test/compile-fail/issue-1448-1.rs index 89189fc1fca..191dda5b4c1 100644 --- a/src/test/compile-fail/issue-1448-1.rs +++ b/src/test/compile-fail/issue-1448-1.rs @@ -3,5 +3,5 @@ fn main() { #macro[[#apply[f, [x, ...]], f(x, ...)]]; fn add(a: int, b: int) -> int { ret a + b; } - assert (#apply[add, [y, 15]] == 16); //~ ERROR unresolved name: y + assert (apply!{add, [y, 15]} == 16); //~ ERROR unresolved name: y } diff --git a/src/test/compile-fail/issue-1448-2.rs b/src/test/compile-fail/issue-1448-2.rs index d91d48ac172..3b16071da2a 100644 --- a/src/test/compile-fail/issue-1448-2.rs +++ b/src/test/compile-fail/issue-1448-2.rs @@ -1,5 +1,5 @@ // Regresion test for issue #1448 and #1386 fn main() { - #debug["%u", 10i]; //~ ERROR mismatched types + debug!{"%u", 10i}; //~ ERROR mismatched types } diff --git a/src/test/compile-fail/liveness-if-with-else.rs b/src/test/compile-fail/liveness-if-with-else.rs index 7f7003dbbe4..edfc22f93e9 100644 --- a/src/test/compile-fail/liveness-if-with-else.rs +++ b/src/test/compile-fail/liveness-if-with-else.rs @@ -3,7 +3,7 @@ fn foo(x: int) { log(debug, x); } fn main() { let x: int; if 1 > 2 { - #debug("whoops"); + debug!{"whoops"}; } else { x = 10; } diff --git a/src/test/compile-fail/liveness-while-break.rs b/src/test/compile-fail/liveness-while-break.rs index c963e2dee4e..dbfaecf1817 100644 --- a/src/test/compile-fail/liveness-while-break.rs +++ b/src/test/compile-fail/liveness-while-break.rs @@ -4,7 +4,7 @@ fn test(cond: bool) { v = 3; break; } - #debug["%d", v]; //~ ERROR use of possibly uninitialized variable: `v` + debug!{"%d", v}; //~ ERROR use of possibly uninitialized variable: `v` } fn main() { diff --git a/src/test/compile-fail/macro-2.rs b/src/test/compile-fail/macro-2.rs index a802301756c..71ae833a139 100644 --- a/src/test/compile-fail/macro-2.rs +++ b/src/test/compile-fail/macro-2.rs @@ -6,5 +6,5 @@ fn main() { f }]]; - assert (#mylambda[y * 1, y * 2](8) == 16); + assert (mylambda!{y * 1, y * 2}(8) == 16); } diff --git a/src/test/compile-fail/macro.rs b/src/test/compile-fail/macro.rs index 5943e575a48..602f074813b 100644 --- a/src/test/compile-fail/macro.rs +++ b/src/test/compile-fail/macro.rs @@ -3,6 +3,6 @@ fn main() { #macro[[#trivial[], 1 * 2 * 4 * 2 * 1]]; - assert (#trivial[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] == + assert (trivial!{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} == 16); } diff --git a/src/test/compile-fail/not-utf8.rs b/src/test/compile-fail/not-utf8.rs index 2038f139359..cbecec982a2 100644 --- a/src/test/compile-fail/not-utf8.rs +++ b/src/test/compile-fail/not-utf8.rs @@ -1,5 +1,5 @@ // error-pattern: is not UTF-8 fn foo() { - #include("not-utf8.bin") + include!{"not-utf8.bin"} } diff --git a/src/test/compile-fail/pure-higher-order.rs b/src/test/compile-fail/pure-higher-order.rs index 13455b1d74f..1add6f7f3fe 100644 --- a/src/test/compile-fail/pure-higher-order.rs +++ b/src/test/compile-fail/pure-higher-order.rs @@ -40,7 +40,7 @@ pure fn range8(from: uint, to: uint) { range(from, to, noop); } -fn print(i: uint) { #error["i=%u", i]; } +fn print(i: uint) { error!{"i=%u", i}; } pure fn noop(_i: uint) {} diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs index c83d26c3a57..80b42622ffd 100644 --- a/src/test/compile-fail/qquote-2.rs +++ b/src/test/compile-fail/qquote-2.rs @@ -37,7 +37,7 @@ fn mk_ctxt() -> fake_ext_ctxt { fn main() { let ext_cx = mk_ctxt(); - let stmt = #ast(stmt){let x int = 20;}; //~ ERROR expected end-of-string + let stmt = #ast[stmt]{let x int = 20;}; //~ ERROR expected end-of-string check_pp(*stmt, pprust::print_stmt, ""); } diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs index fbef015ea7f..2aa84a273ec 100644 --- a/src/test/compile-fail/regions-addr-of-self.rs +++ b/src/test/compile-fail/regions-addr-of-self.rs @@ -19,5 +19,6 @@ class dog { fn main() { let d = dog(); d.chase_cat(); - #debug["cats_chased: %u", d.cats_chased]; + debug!{"cats_chased: %u", d.cats_chased}; } + diff --git a/src/test/compile-fail/regions-escape-via-iface-or-not.rs b/src/test/compile-fail/regions-escape-via-iface-or-not.rs index 415e66fbda2..297b183a1b4 100644 --- a/src/test/compile-fail/regions-escape-via-iface-or-not.rs +++ b/src/test/compile-fail/regions-escape-via-iface-or-not.rs @@ -20,5 +20,5 @@ fn return_it() -> int { fn main() { let x = return_it(); - #debug["foo=%d", x]; + debug!{"foo=%d", x}; } diff --git a/src/test/compile-fail/regions-ret-borrowed-1.rs b/src/test/compile-fail/regions-ret-borrowed-1.rs index 86210b25a10..1b59839f092 100644 --- a/src/test/compile-fail/regions-ret-borrowed-1.rs +++ b/src/test/compile-fail/regions-ret-borrowed-1.rs @@ -13,5 +13,5 @@ fn return_it() -> &a/int { fn main() { let x = return_it(); - #debug["foo=%d", *x]; + debug!{"foo=%d", *x}; } diff --git a/src/test/compile-fail/regions-ret-borrowed.rs b/src/test/compile-fail/regions-ret-borrowed.rs index 3bd3deefcf5..557394de741 100644 --- a/src/test/compile-fail/regions-ret-borrowed.rs +++ b/src/test/compile-fail/regions-ret-borrowed.rs @@ -16,5 +16,5 @@ fn return_it() -> &int { fn main() { let x = return_it(); - #debug["foo=%d", *x]; + debug!{"foo=%d", *x}; } diff --git a/src/test/compile-fail/unbalanced-comment.rs b/src/test/compile-fail/unbalanced-comment.rs index 52b49723691..24ac09a2d41 100644 --- a/src/test/compile-fail/unbalanced-comment.rs +++ b/src/test/compile-fail/unbalanced-comment.rs @@ -7,5 +7,5 @@ */ fn main() { - #debug("hello, world."); + debug!{"hello, world."}; } diff --git a/src/test/pretty/block-arg-disambig.rs b/src/test/pretty/block-arg-disambig.rs index 3d7203efed5..8a4297d95b2 100644 --- a/src/test/pretty/block-arg-disambig.rs +++ b/src/test/pretty/block-arg-disambig.rs @@ -2,4 +2,4 @@ // is probably not necessary anymore (#2882) fn blk1(b: fn()) -> fn@() { ret fn@() { }; } -fn test1() { (do blk1 { #debug["hi"]; })(); } +fn test1() { (do blk1 { debug!{"hi"}; })(); } diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs index 111367c8020..a5890b39fda 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs @@ -10,8 +10,8 @@ fn main() { // wrap around to a small number. let idx = uint::max_value & !(uint::max_value >> 1u); - #error("ov2 idx = 0x%x", idx); + error!{"ov2 idx = 0x%x", idx}; // This should fail. - #error("ov2 0x%x", x[idx]); + error!{"ov2 0x%x", x[idx]}; } \ No newline at end of file diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs index 7e9853eaccb..c8755780408 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs @@ -12,17 +12,17 @@ fn main() { // This test is only meaningful on 32-bit hosts. let idx = u64::max_value & !(u64::max_value >> 1u); - #error("ov3 idx = 0x%8.8x%8.8x", + error!{"ov3 idx = 0x%8.8x%8.8x", (idx >> 32) as uint, - idx as uint); + idx as uint}; // This should fail. - #error("ov3 0x%x", x[idx]); + error!{"ov3 0x%x", x[idx]}; } #[cfg(target_arch="x86_64")] fn main() { // This version just fails anyways, for symmetry on 64-bit hosts. let x = ~[1u,2u,3u]; - #error("ov3 0x%x", x[200]); + error!{"ov3 0x%x", x[200]}; } diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs index abf1bc5d6c8..fdaaf2fe445 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs @@ -12,13 +12,13 @@ fn main() { do vec::as_buf(x) |p, _len| { let base = p as uint; // base = 0x1230 say let idx = base / sys::size_of::<uint>(); // idx = 0x0246 say - #error("ov1 base = 0x%x", base); - #error("ov1 idx = 0x%x", idx); - #error("ov1 sizeof::<uint>() = 0x%x", sys::size_of::<uint>()); - #error("ov1 idx * sizeof::<uint>() = 0x%x", - idx * sys::size_of::<uint>()); + error!{"ov1 base = 0x%x", base}; + error!{"ov1 idx = 0x%x", idx}; + error!{"ov1 sizeof::<uint>() = 0x%x", sys::size_of::<uint>()}; + error!{"ov1 idx * sizeof::<uint>() = 0x%x", + idx * sys::size_of::<uint>()}; // This should fail. - #error("ov1 0x%x", x[idx]); + error!{"ov1 0x%x", x[idx]}; } } \ No newline at end of file diff --git a/src/test/run-fail/extern-fail.rs b/src/test/run-fail/extern-fail.rs index 0ae0edf1397..4b5a41c6eb2 100644 --- a/src/test/run-fail/extern-fail.rs +++ b/src/test/run-fail/extern-fail.rs @@ -24,7 +24,7 @@ fn main() { for iter::repeat(10u) { do task::spawn { let result = count(5u); - #debug("result = %?", result); + debug!{"result = %?", result}; fail; }; } diff --git a/src/test/run-fail/fmt-fail.rs b/src/test/run-fail/fmt-fail.rs index 3950495e9c4..e45207c2ec6 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-pass-fulldeps/issue-1926.rs b/src/test/run-pass-fulldeps/issue-1926.rs index 6be105e52ca..f4dbf24f005 100644 --- a/src/test/run-pass-fulldeps/issue-1926.rs +++ b/src/test/run-pass-fulldeps/issue-1926.rs @@ -46,8 +46,8 @@ fn mk_ctxt() -> fake_ext_ctxt { fn main() { let ext_cx = mk_ctxt(); - let s = #ast(expr){__s}; - let e = #ast(expr){__e}; - let f = #ast(expr){$(s).foo {|__e| $(e)}}; + let s = #ast[expr]{__s}; + let e = #ast[expr]{__e}; + let f = #ast[expr]{$(s).foo {|__e| $(e)}}; log(error, pprust::expr_to_str(f)); } diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index 171531c5fb8..173884d1d66 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -40,25 +40,25 @@ fn main() { let expr4 = #ast{2 - $(#ast{3}) + 9}; check_pp(expr4, pprust::print_expr, ~"2 - 3 + 9"); - let ty = #ast(ty){int}; + let ty = #ast[ty]{int}; check_pp(ty, pprust::print_type, ~"int"); - let ty2 = #ast(ty){option<$(ty)>}; + let ty2 = #ast[ty]{option<$(ty)>}; check_pp(ty2, pprust::print_type, ~"option<int>"); - let item = #ast(item){const x : int = 10;}; + let item = #ast[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);}; + let item2: @ast::item = #ast[item]{const x : int = $(abc);}; check_pp(item2, pprust::print_item, ~"const x: int = 23;"); - let stmt = #ast(stmt){let x = 20;}; + let stmt = #ast[stmt]{let x = 20;}; check_pp(*stmt, pprust::print_stmt, ~"let x = 20;"); - let stmt2 = #ast(stmt){let x : $(ty) = $(abc);}; + let stmt2 = #ast[stmt]{let x : $(ty) = $(abc);}; check_pp(*stmt2, pprust::print_stmt, ~"let x: int = 23;"); - let pat = #ast(pat){some(_)}; + let pat = #ast[pat]{some(_)}; check_pp(pat, pprust::print_pat, ~"some(_)"); // issue #1785 @@ -73,13 +73,13 @@ fn main() { let test3 = #ast{$(x) + $(y)}; check_pp(test3, pprust::print_expr, ~"1 + 2"); - let crate = #ast(crate) { fn a() { } }; + let crate = #ast[crate] { fn a() { } }; 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) )}; + 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)") } @@ -91,7 +91,7 @@ fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: ~str) { let str = mem_buffer_str(buf); stdout().write_line(str); if expect != ~"" { - #error("expect: '%s', got: '%s'", expect, str); + error!{"expect: '%s', got: '%s'", expect, str}; assert str == expect; } } diff --git a/src/test/run-pass/acyclic-unwind.rs b/src/test/run-pass/acyclic-unwind.rs index 21fb2f174bd..af2310926f1 100644 --- a/src/test/run-pass/acyclic-unwind.rs +++ b/src/test/run-pass/acyclic-unwind.rs @@ -17,7 +17,7 @@ fn f(c: comm::_chan<int>) { loop { // spin waiting for the parent to kill us. - #debug("child waiting to die..."); + debug!{"child waiting to die..."}; // while waiting to die, the messages we are // sending to the channel are never received @@ -35,5 +35,5 @@ fn main() { // synchronize on event from child. i = p.recv(); - #debug("parent exiting, killing child"); + debug!{"parent exiting, killing child"}; } diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs index 04f07001810..d2fd007f1a8 100644 --- a/src/test/run-pass/alignment-gep-tup-like-1.rs +++ b/src/test/run-pass/alignment-gep-tup-like-1.rs @@ -8,7 +8,7 @@ fn f<A:copy owned>(a: A, b: u16) -> fn@() -> (A, u16) { fn main() { let (a, b) = f(22_u64, 44u16)(); - #debug["a=%? b=%?", a, b]; + debug!{"a=%? b=%?", a, b}; assert a == 22u64; assert b == 44u16; } \ No newline at end of file diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs index ab599a44c0b..8d4315b8daa 100644 --- a/src/test/run-pass/alignment-gep-tup-like-2.rs +++ b/src/test/run-pass/alignment-gep-tup-like-2.rs @@ -23,7 +23,7 @@ fn main() { let z = f(~x, y); make_cycle(z); let (a, b) = z(); - #debug["a=%u b=%u", *a as uint, b as uint]; + debug!{"a=%u b=%u", *a as uint, b as uint}; assert *a == x; assert b == y; } \ No newline at end of file diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs index a7b6bd98ecd..637c2c8dabf 100644 --- a/src/test/run-pass/alt-join.rs +++ b/src/test/run-pass/alt-join.rs @@ -13,4 +13,4 @@ fn foo<T>(y: option<T>) { ret; } -fn main() { #debug("hello"); foo::<int>(some::<int>(5)); } +fn main() { debug!{"hello"}; foo::<int>(some::<int>(5)); } diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs index ce2996f01e0..b8ce7299271 100644 --- a/src/test/run-pass/alt-pattern-drop.rs +++ b/src/test/run-pass/alt-pattern-drop.rs @@ -14,7 +14,7 @@ fn foo(s: @int) { log(debug, y); // ref up then down } - _ { #debug("?"); fail; } + _ { debug!{"?"}; fail; } } log(debug, sys::refcount(s)); assert (sys::refcount(s) == count + 1u); diff --git a/src/test/run-pass/alt-pattern-lit.rs b/src/test/run-pass/alt-pattern-lit.rs index d266a63418f..e904818d688 100644 --- a/src/test/run-pass/alt-pattern-lit.rs +++ b/src/test/run-pass/alt-pattern-lit.rs @@ -2,8 +2,8 @@ fn altlit(f: int) -> int { alt check f { - 10 { #debug("case 10"); ret 20; } - 11 { #debug("case 11"); ret 22; } + 10 { debug!{"case 10"}; ret 20; } + 11 { debug!{"case 11"}; ret 22; } } } diff --git a/src/test/run-pass/alt-pattern-no-type-params.rs b/src/test/run-pass/alt-pattern-no-type-params.rs index 9a9acad43fd..91340f94333 100644 --- a/src/test/run-pass/alt-pattern-no-type-params.rs +++ b/src/test/run-pass/alt-pattern-no-type-params.rs @@ -1,7 +1,7 @@ enum maybe<T> { nothing, just(T), } fn foo(x: maybe<int>) { - alt x { nothing { #error("A"); } just(a) { #error("B"); } } + alt x { nothing { error!{"A"}; } just(a) { error!{"B"}; } } } fn main() { } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index 7bd21a114c9..98fdb9ee2b8 100644 --- a/src/test/run-pass/alt-tag.rs +++ b/src/test/run-pass/alt-tag.rs @@ -11,9 +11,9 @@ enum color { fn process(c: color) -> int { let mut x: int; alt c { - rgb(r, _, _) { #debug("rgb"); log(debug, r); x = r; } - rgba(_, _, _, a) { #debug("rgba"); log(debug, a); x = a; } - hsl(_, s, _) { #debug("hsl"); log(debug, s); x = s; } + rgb(r, _, _) { debug!{"rgb"}; log(debug, r); x = r; } + rgba(_, _, _, a) { debug!{"rgba"}; log(debug, a); x = a; } + hsl(_, s, _) { debug!{"hsl"}; log(debug, s); x = s; } } ret x; } diff --git a/src/test/run-pass/alt-unique-bind.rs b/src/test/run-pass/alt-unique-bind.rs index 7bec545b35d..0f47c910529 100644 --- a/src/test/run-pass/alt-unique-bind.rs +++ b/src/test/run-pass/alt-unique-bind.rs @@ -1,7 +1,7 @@ fn main() { alt ~100 { ~x { - #debug("%?", x); + debug!{"%?", x}; assert x == 100; } } diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs index 1f1c2a6c707..46e743cde6c 100644 --- a/src/test/run-pass/auto_serialize.rs +++ b/src/test/run-pass/auto_serialize.rs @@ -19,7 +19,7 @@ fn test_ser_and_deser<A>(a1: A, // check the pretty printer: io_ser_fn(io::stdout(), a1); let s = io::with_str_writer(|w| io_ser_fn(w, a1) ); - #debug["s == %?", s]; + debug!{"s == %?", s}; assert s == expected; // check the EBML serializer: diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs index 4b912938e4a..31d04b88d44 100644 --- a/src/test/run-pass/basic-1.rs +++ b/src/test/run-pass/basic-1.rs @@ -17,15 +17,15 @@ fn main() { let mut n: int = 0; n = recv(p); n = recv(p); - // #debug("Finished."); + // debug!{"Finished."}; } fn b(c: chan<int>) { - // #debug("task b0"); - // #debug("task b1"); - // #debug("task b2"); - // #debug("task b3"); - // #debug("task b4"); - // #debug("task b5"); + // debug!{"task b0"}; + // debug!{"task b1"}; + // debug!{"task b2"}; + // debug!{"task b3"}; + // debug!{"task b4"}; + // debug!{"task b5"}; send(c, 10); } diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs index 039caef3d99..ba81fb1ff9b 100644 --- a/src/test/run-pass/basic-2.rs +++ b/src/test/run-pass/basic-2.rs @@ -8,7 +8,7 @@ import comm::chan; import comm::recv; import task; -fn a(c: chan<int>) { #debug("task a0"); #debug("task a1"); send(c, 10); } +fn a(c: chan<int>) { debug!{"task a0"}; debug!{"task a1"}; send(c, 10); } fn main() { let p = port(); @@ -18,14 +18,14 @@ fn main() { let mut n: int = 0; n = recv(p); n = recv(p); - #debug("Finished."); + debug!{"Finished."}; } fn b(c: chan<int>) { - #debug("task b0"); - #debug("task b1"); - #debug("task b2"); - #debug("task b2"); - #debug("task b3"); + debug!{"task b0"}; + debug!{"task b1"}; + debug!{"task b2"}; + debug!{"task b2"}; + debug!{"task b3"}; send(c, 10); } diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs index b0fa0e3576e..786b34cb984 100644 --- a/src/test/run-pass/basic.rs +++ b/src/test/run-pass/basic.rs @@ -9,11 +9,11 @@ import task; fn a(c: chan<int>) { if true { - #debug("task a"); - #debug("task a"); - #debug("task a"); - #debug("task a"); - #debug("task a"); + debug!{"task a"}; + debug!{"task a"}; + debug!{"task a"}; + debug!{"task a"}; + debug!{"task a"}; } send(c, 10); } @@ -39,17 +39,17 @@ fn main() { log(debug, x); n = recv(p); n = recv(p); - #debug("children finished, root finishing"); + debug!{"children finished, root finishing"}; } fn b(c: chan<int>) { if true { - #debug("task b"); - #debug("task b"); - #debug("task b"); - #debug("task b"); - #debug("task b"); - #debug("task b"); + debug!{"task b"}; + debug!{"task b"}; + debug!{"task b"}; + debug!{"task b"}; + debug!{"task b"}; + debug!{"task b"}; } send(c, 10); } diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index 365198a0fbc..19bfaac0f0c 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -136,9 +136,9 @@ fn test_class() { let r = p(1, 2); unsafe { - #error("q = %x, r = %x", + error!{"q = %x, r = %x", (unsafe::reinterpret_cast::<*p, uint>(ptr::addr_of(q))), - (unsafe::reinterpret_cast::<*p, uint>(ptr::addr_of(r)))); + (unsafe::reinterpret_cast::<*p, uint>(ptr::addr_of(r)))}; } assert(q == r); r.y = 17; diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs index c01a9feab7d..f3eed8cc26d 100644 --- a/src/test/run-pass/borrowck-mut-uniq.rs +++ b/src/test/run-pass/borrowck-mut-uniq.rs @@ -19,8 +19,8 @@ fn main() { add_int(ints, 44); for iter_ints(ints) |i| { - #error["int = %d", *i]; + error!{"int = %d", *i}; } - #error["ints=%?", ints]; + error!{"ints=%?", ints}; } diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs index f486ffe557d..0bbd2b2d90a 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs @@ -9,7 +9,7 @@ fn main() { x = @{f: ~4}; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs index 9320d91e4a0..17831948b54 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-field.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs @@ -14,7 +14,7 @@ fn main() { assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x); x = @{f: ~4}; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs index 0bad47642a0..cf738e02d2f 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs @@ -9,7 +9,7 @@ fn main() { *x = @{f: ~4}; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs index abe1faeed59..05f403425b3 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs @@ -14,7 +14,7 @@ fn main() { assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x); *x = @{f: ~4}; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs index 68c7c768618..886d9172cec 100644 --- a/src/test/run-pass/borrowck-preserve-box.rs +++ b/src/test/run-pass/borrowck-preserve-box.rs @@ -14,7 +14,7 @@ fn main() { assert ptr::addr_of(*x) == ptr::addr_of(*b_x); x = @22; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/borrowck-preserve-cond-box.rs b/src/test/run-pass/borrowck-preserve-cond-box.rs index 0ee7ce18761..c5d815834b2 100644 --- a/src/test/run-pass/borrowck-preserve-cond-box.rs +++ b/src/test/run-pass/borrowck-preserve-cond-box.rs @@ -14,13 +14,13 @@ fn testfn(cond: bool) { exp = 4; } - #debug["*r = %d, exp = %d", *r, exp]; + debug!{"*r = %d, exp = %d", *r, exp}; assert *r == exp; x = @5; y = @6; - #debug["*r = %d, exp = %d", *r, exp]; + debug!{"*r = %d, exp = %d", *r, exp}; assert *r == exp; } diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs index f04c81527c2..30f33beea48 100644 --- a/src/test/run-pass/borrowck-preserve-expl-deref.rs +++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs @@ -14,7 +14,7 @@ fn main() { assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x); x = @{f: ~4}; - #debug["ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint]; + debug!{"ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint}; assert *b_x == 3; assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x); } diff --git a/src/test/run-pass/box-inside-if.rs b/src/test/run-pass/box-inside-if.rs index caa70c953af..3366906ec94 100644 --- a/src/test/run-pass/box-inside-if.rs +++ b/src/test/run-pass/box-inside-if.rs @@ -9,7 +9,7 @@ fn is_odd(n: int) -> bool { ret true; } fn length_is_even(vs: @int) -> bool { ret true; } fn foo(acc: int, n: int) { - if is_odd(n) && length_is_even(some_box(1)) { #error("bloop"); } + if is_odd(n) && length_is_even(some_box(1)) { error!{"bloop"}; } } fn main() { foo(67, 5); } diff --git a/src/test/run-pass/box-inside-if2.rs b/src/test/run-pass/box-inside-if2.rs index 437a167cd6a..97a7a919712 100644 --- a/src/test/run-pass/box-inside-if2.rs +++ b/src/test/run-pass/box-inside-if2.rs @@ -9,7 +9,7 @@ fn is_odd(n: int) -> bool { ret true; } fn length_is_even(vs: @int) -> bool { ret true; } fn foo(acc: int, n: int) { - if is_odd(n) || length_is_even(some_box(1)) { #error("bloop"); } + if is_odd(n) || length_is_even(some_box(1)) { error!{"bloop"}; } } fn main() { foo(67, 5); } diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index be9981ccdbe..48c7c046d37 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -7,6 +7,6 @@ fn unbox<T: copy>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; - #debug("see what's in our box"); + debug!{"see what's in our box"}; assert (unbox::<int>(bfoo) == foo); } diff --git a/src/test/run-pass/by-val-and-by-move.rs b/src/test/run-pass/by-val-and-by-move.rs index aa65c1aef6f..5a174f4c4aa 100644 --- a/src/test/run-pass/by-val-and-by-move.rs +++ b/src/test/run-pass/by-val-and-by-move.rs @@ -3,7 +3,7 @@ fn it_takes_two(x: @int, -y: @int) -> int { free(y); - #debug["about to deref"]; + debug!{"about to deref"}; *x } diff --git a/src/test/run-pass/cast-region-to-uint.rs b/src/test/run-pass/cast-region-to-uint.rs index 6cf82783831..7372450f496 100644 --- a/src/test/run-pass/cast-region-to-uint.rs +++ b/src/test/run-pass/cast-region-to-uint.rs @@ -1,4 +1,4 @@ fn main() { let x = 3; - #debug["&x=%x", &x as uint]; + debug!{"&x=%x", &x as uint}; } \ No newline at end of file diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs index f15481d64fe..95de5dddf6d 100644 --- a/src/test/run-pass/cci_borrow.rs +++ b/src/test/run-pass/cci_borrow.rs @@ -7,6 +7,6 @@ import cci_borrow_lib::foo; fn main() { let p = @22u; let r = foo(p); - #debug["r=%u", r]; + debug!{"r=%u", r}; assert r == 22u; } diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs index 04dd607d76e..55bb9a8ad35 100644 --- a/src/test/run-pass/cci_impl_exe.rs +++ b/src/test/run-pass/cci_impl_exe.rs @@ -7,13 +7,13 @@ import cci_impl_lib::uint_helpers; fn main() { //let bt0 = sys::frame_address(); - //#debug["%?", bt0]; + //debug!{"%?", bt0}; do 3u.to(10u) |i| { - io::print(#fmt["%u\n", i]); + io::print(fmt!{"%u\n", i}); //let bt1 = sys::frame_address(); - //#debug["%?", bt1]; + //debug!{"%?", bt1}; //assert bt0 == bt1; } } diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs index 9e8986bd5ba..0ba2a2190fe 100644 --- a/src/test/run-pass/cci_iter_exe.rs +++ b/src/test/run-pass/cci_iter_exe.rs @@ -5,9 +5,9 @@ use cci_iter_lib; fn main() { //let bt0 = sys::rusti::frame_address(1u32); - //#debug["%?", bt0]; + //debug!{"%?", bt0}; do cci_iter_lib::iter(~[1, 2, 3]) |i| { - io::print(#fmt["%d", i]); + io::print(fmt!{"%d", i}); //assert bt0 == sys::rusti::frame_address(2u32); } } diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs index 070cad2dfb4..51bc773b5c8 100644 --- a/src/test/run-pass/cci_no_inline_exe.rs +++ b/src/test/run-pass/cci_no_inline_exe.rs @@ -11,12 +11,12 @@ fn main() { // sys::frame_address() to determine if we are inlining is // actually working. //let bt0 = sys::frame_address(); - //#debug["%?", bt0]; + //debug!{"%?", bt0}; do iter(~[1u, 2u, 3u]) |i| { - io::print(#fmt["%u\n", i]); + io::print(fmt!{"%u\n", i}); //let bt1 = sys::frame_address(); - //#debug["%?", bt1]; + //debug!{"%?", bt1}; //assert bt0 != bt1; } diff --git a/src/test/run-pass/class-attributes-1.rs b/src/test/run-pass/class-attributes-1.rs index 36e1ca621f9..b41359b735f 100644 --- a/src/test/run-pass/class-attributes-1.rs +++ b/src/test/run-pass/class-attributes-1.rs @@ -4,7 +4,7 @@ class cat { #[cat_maker] new(name: ~str) { self.name = name; } #[cat_dropper] - drop { #error["%s landed on hir feet", self.name]; } + drop { error!{"%s landed on hir feet", self.name}; } let name: ~str; } diff --git a/src/test/run-pass/class-attributes-2.rs b/src/test/run-pass/class-attributes-2.rs index 8c75d7f6b5a..d08ef04eca6 100644 --- a/src/test/run-pass/class-attributes-2.rs +++ b/src/test/run-pass/class-attributes-2.rs @@ -9,7 +9,7 @@ class cat { /** Actually, cats don't always land on their feet when you drop them. */ - drop { #error("%s landed on hir feet", self.name); } + drop { error!{"%s landed on hir feet", self.name}; } } fn main() { 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 0afe1cedfaa..24ffaa22cd4 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 @@ -6,7 +6,7 @@ import cci_class_cast::kitty::*; fn print_out<T: to_str>(thing: T, expected: ~str) { let actual = thing.to_str(); - #debug("%s", actual); + debug!{"%s", actual}; assert(actual == expected); } diff --git a/src/test/run-pass/class-cast-to-iface-cross-crate.rs b/src/test/run-pass/class-cast-to-iface-cross-crate.rs index bf9a4947177..765aba74cc2 100644 --- a/src/test/run-pass/class-cast-to-iface-cross-crate.rs +++ b/src/test/run-pass/class-cast-to-iface-cross-crate.rs @@ -7,7 +7,7 @@ class cat : to_str { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -25,12 +25,12 @@ class cat : to_str { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } @@ -40,7 +40,7 @@ class cat : to_str { fn print_out<T: to_str>(thing: T, expected: str) { let actual = thing.to_str(); - #debug("%s", actual); + debug!{"%s", actual}; assert(actual == expected); } 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 23d0a203a70..a55ef9f8bd7 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 @@ -6,7 +6,7 @@ class dog : noisy { priv { let barks : @mut uint; fn bark() -> int { - #debug("Woof %u %d", *self.barks, *self.volume); + debug!{"Woof %u %d", *self.barks, *self.volume}; *self.barks += 1u; if *self.barks % 3u == 0u { *self.volume += 1; @@ -14,7 +14,7 @@ class dog : noisy { if *self.barks % 10u == 0u { *self.volume -= 2; } - #debug("Grrr %u %d", *self.barks, *self.volume); + debug!{"Grrr %u %d", *self.barks, *self.volume}; *self.volume } } @@ -30,7 +30,7 @@ class cat : noisy { priv { let meows : @mut uint; fn meow() -> uint { - #debug("Meow"); + debug!{"Meow"}; *self.meows += 1u; if *self.meows % 5u == 0u { *self.how_hungry += 1; diff --git a/src/test/run-pass/class-cast-to-iface.rs b/src/test/run-pass/class-cast-to-iface.rs index e35152bd1d9..bba7540d22b 100644 --- a/src/test/run-pass/class-cast-to-iface.rs +++ b/src/test/run-pass/class-cast-to-iface.rs @@ -6,7 +6,7 @@ class cat : noisy { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -24,12 +24,12 @@ class cat : noisy { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/run-pass/class-impl-parameterized-iface.rs b/src/test/run-pass/class-impl-parameterized-iface.rs index eb9422a7c7c..fe31eb7a380 100644 --- a/src/test/run-pass/class-impl-parameterized-iface.rs +++ b/src/test/run-pass/class-impl-parameterized-iface.rs @@ -10,7 +10,7 @@ class cat : map<int, bool> { let mut meows : int; fn meow() { self.meows += 1; - #error("Meow %d", self.meows); + error!{"Meow %d", self.meows}; if self.meows % 5 == 0 { self.how_hungry += 1; } @@ -27,12 +27,12 @@ class cat : map<int, bool> { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } 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 425364945f0..4126df0f5b7 100644 --- a/src/test/run-pass/class-impl-very-parameterized-iface.rs +++ b/src/test/run-pass/class-impl-very-parameterized-iface.rs @@ -13,7 +13,7 @@ class cat<T: copy> : map<int, T> { let mut meows : int; fn meow() { self.meows += 1; - #error("Meow %d", self.meows); + error!{"Meow %d", self.meows}; if self.meows % 5 == 0 { self.how_hungry += 1; } @@ -30,12 +30,12 @@ class cat<T: copy> : map<int, T> { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } 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 a8a22f44447..a66289a7ece 100644 --- a/src/test/run-pass/class-implement-iface-cross-crate.rs +++ b/src/test/run-pass/class-implement-iface-cross-crate.rs @@ -7,7 +7,7 @@ class cat : noisy { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -25,12 +25,12 @@ class cat : noisy { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/run-pass/class-implement-ifaces.rs b/src/test/run-pass/class-implement-ifaces.rs index c506e031c98..eedc308a460 100644 --- a/src/test/run-pass/class-implement-ifaces.rs +++ b/src/test/run-pass/class-implement-ifaces.rs @@ -6,7 +6,7 @@ class cat : noisy { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -24,12 +24,12 @@ class cat : noisy { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/run-pass/class-implements-multiple-ifaces.rs b/src/test/run-pass/class-implements-multiple-ifaces.rs index 306145640a1..b8fd1dd2f27 100644 --- a/src/test/run-pass/class-implements-multiple-ifaces.rs +++ b/src/test/run-pass/class-implements-multiple-ifaces.rs @@ -33,7 +33,7 @@ class cat : noisy, scratchy, bitey { let bite_counts : hashmap<body_part, uint>; fn meow() -> uint { - #debug("Meow: %u", *self.meows); + debug!{"Meow: %u", *self.meows}; *self.meows += 1u; if *self.meows % 5u == 0u { *self.how_hungry += 1; @@ -72,16 +72,16 @@ class cat : noisy, scratchy, bitey { rslt } fn bite() -> body_part { - #error("In bite()"); + error!{"In bite()"}; let all = ~[toe, nose, ear]; let mut min = finger; do iter(all) |next| { - #debug("min = %?", min); + debug!{"min = %?", min}; if self.bite_counts.get(next) < self.bite_counts.get(min) { min = next; }}; self.bite_counts.insert(min, self.bite_counts.get(min) + 1u); - #debug("Bit %?", min); + debug!{"Bit %?", min}; min } } @@ -89,7 +89,7 @@ class cat : noisy, scratchy, bitey { fn annoy_neighbors<T: noisy>(critter: T) { for uint::range(0u, 10u) |i| { let what = critter.speak(); - #debug("%u %d", i, what); + debug!{"%u %d", i, what}; } } @@ -97,7 +97,7 @@ fn bite_everything<T: bitey>(critter: T) -> bool { let mut left : ~[body_part] = ~[finger, toe, nose, ear]; while vec::len(left) > 0u { let part = critter.bite(); - #debug("%? %?", left, part); + debug!{"%? %?", left, part}; if vec_includes(left, part) { left = vec::filter(left, |p| p != part ); } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index 82f46c74874..35c462e9dc2 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -6,7 +6,7 @@ class cat { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -24,12 +24,12 @@ class cat { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } @@ -41,7 +41,7 @@ impl of to_str for cat { fn print_out<T: to_str>(thing: T, expected: ~str) { let actual = thing.to_str(); - #debug("%s", actual); + debug!{"%s", actual}; assert(actual == expected); } diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs index 697b4c79676..175d2c35c77 100644 --- a/src/test/run-pass/classes.rs +++ b/src/test/run-pass/classes.rs @@ -2,7 +2,7 @@ class cat { priv { let mut meows : uint; fn meow() { - #error("Meow"); + error!{"Meow"}; self.meows += 1u; if self.meows % 5u == 0u { self.how_hungry += 1; @@ -20,12 +20,12 @@ class cat { fn eat() -> bool { if self.how_hungry > 0 { - #error("OM NOM NOM"); + error!{"OM NOM NOM"}; self.how_hungry -= 2; ret true; } else { - #error("Not hungry!"); + error!{"Not hungry!"}; ret false; } } diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs index 20f4a8055e8..6e67451f6d9 100644 --- a/src/test/run-pass/close-over-big-then-small-data.rs +++ b/src/test/run-pass/close-over-big-then-small-data.rs @@ -12,7 +12,7 @@ fn f<A:copy owned>(a: A, b: u16) -> fn@() -> (A, u16) { fn main() { let (a, b) = f(22_u64, 44u16)(); - #debug["a=%? b=%?", a, b]; + debug!{"a=%? b=%?", a, b}; assert a == 22u64; assert b == 44u16; } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index bb6f6585850..d5be0affdb9 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -12,13 +12,13 @@ fn main() { let ch = comm::chan(p); let t = task::spawn(|| child(ch) ); let y = recv(p); - #error("received"); + error!{"received"}; log(error, y); assert (y == 10); } fn child(c: chan<int>) { - #error("sending"); + error!{"sending"}; send(c, 10); - #error("value sent"); + error!{"value sent"}; } diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs index 3ac0c75da11..104c312d673 100644 --- a/src/test/run-pass/complex.rs +++ b/src/test/run-pass/complex.rs @@ -28,6 +28,6 @@ fn foo(x: int) -> int { fn main() { let x: int = 2 + 2; log(debug, x); - #debug("hello, world"); + debug!{"hello, world"}; log(debug, 10); } diff --git a/src/test/run-pass/dead-code-one-arm-if.rs b/src/test/run-pass/dead-code-one-arm-if.rs index f79072068da..0785005fac9 100644 --- a/src/test/run-pass/dead-code-one-arm-if.rs +++ b/src/test/run-pass/dead-code-one-arm-if.rs @@ -2,4 +2,4 @@ // -*- rust -*- -fn main() { if 1 == 1 { ret; } #debug("Paul is dead"); } +fn main() { if 1 == 1 { ret; } debug!{"Paul is dead"}; } diff --git a/src/test/run-pass/export-non-interference2.rs b/src/test/run-pass/export-non-interference2.rs index 007e25a251c..a091e975177 100644 --- a/src/test/run-pass/export-non-interference2.rs +++ b/src/test/run-pass/export-non-interference2.rs @@ -6,7 +6,7 @@ mod foo { fn y() { x(); } } - fn x() { #debug("x"); } + fn x() { debug!{"x"}; } } fn main() { foo::bar::y(); } diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs index 161ab05e266..55b45d626e1 100644 --- a/src/test/run-pass/export-non-interference3.rs +++ b/src/test/run-pass/export-non-interference3.rs @@ -7,7 +7,7 @@ mod foo { mod bar { export x; - fn x() { #debug("x"); } + fn x() { debug!{"x"}; } } fn main() { foo::x(); } diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs index e0d313ea54c..146f371f290 100644 --- a/src/test/run-pass/extern-call-deep.rs +++ b/src/test/run-pass/extern-call-deep.rs @@ -12,12 +12,12 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { } fn count(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; rustrt::rust_dbg_call(cb, n) } fn main() { let result = count(1000u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 1000u; } \ No newline at end of file diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs index c599a1576cc..f9fbc1773bd 100644 --- a/src/test/run-pass/extern-call-deep2.rs +++ b/src/test/run-pass/extern-call-deep2.rs @@ -12,7 +12,7 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { } fn count(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; rustrt::rust_dbg_call(cb, n) } @@ -21,7 +21,7 @@ fn main() { // has a large stack) do task::spawn { let result = count(1000u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 1000u; }; } \ No newline at end of file diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index a54dd58062f..4f7c7e233a7 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -16,7 +16,7 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { } fn count(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; rustrt::rust_dbg_call(cb, n) } @@ -25,7 +25,7 @@ fn main() { // has a large stack) do task::spawn { let result = count(12u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 2048u; }; } \ No newline at end of file diff --git a/src/test/run-pass/extern-call.rs b/src/test/run-pass/extern-call.rs index 88ee55d856e..7634d347cad 100644 --- a/src/test/run-pass/extern-call.rs +++ b/src/test/run-pass/extern-call.rs @@ -12,12 +12,12 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { } fn fact(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; rustrt::rust_dbg_call(cb, n) } fn main() { let result = fact(10u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 3628800u; } \ No newline at end of file diff --git a/src/test/run-pass/extern-crosscrate.rs b/src/test/run-pass/extern-crosscrate.rs index afe33dcfcea..290dc115a0b 100644 --- a/src/test/run-pass/extern-crosscrate.rs +++ b/src/test/run-pass/extern-crosscrate.rs @@ -4,12 +4,12 @@ use externcallback(vers = "0.1"); fn fact(n: uint) -> uint { - #debug("n = %?", n); + debug!{"n = %?", n}; externcallback::rustrt::rust_dbg_call(externcallback::cb, n) } fn main() { let result = fact(10u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 3628800u; } diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index 87d8eb27937..194970789c1 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -20,7 +20,7 @@ fn main() { for iter::repeat(10u) { do task::spawn { let result = count(5u); - #debug("result = %?", result); + debug!{"result = %?", result}; assert result == 16u; }; } diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index 082a7d65bca..bf2329a94ff 100644 --- a/src/test/run-pass/fact.rs +++ b/src/test/run-pass/fact.rs @@ -3,18 +3,18 @@ // -*- rust -*- fn f(x: int) -> int { - // #debug("in f:"); + // debug!{"in f:"}; log(debug, x); if x == 1 { - // #debug("bottoming out"); + // debug!{"bottoming out"}; ret 1; } else { - // #debug("recurring"); + // debug!{"recurring"}; let y: int = x * f(x - 1); - // #debug("returned"); + // debug!{"returned"}; log(debug, y); ret y; @@ -23,6 +23,6 @@ fn f(x: int) -> int { fn main() { assert (f(5) == 120); - // #debug("all done"); + // debug!{"all done"}; } diff --git a/src/test/run-pass/float.rs b/src/test/run-pass/float.rs index d13e08c7ed3..262ce59ae58 100644 --- a/src/test/run-pass/float.rs +++ b/src/test/run-pass/float.rs @@ -5,6 +5,6 @@ fn main() { log(debug, -pi * (pi + 2.0 / pi) - pi * 5.0); if pi == 5.0 || pi < 10.0 || pi <= 2.0 || pi != 22.0 / 7.0 || pi >= 10.0 || pi > 1.0 { - #debug("yes"); + debug!{"yes"}; } } diff --git a/src/test/run-pass/fn-bare-item.rs b/src/test/run-pass/fn-bare-item.rs index 2baea9846ab..6ab3deb7433 100644 --- a/src/test/run-pass/fn-bare-item.rs +++ b/src/test/run-pass/fn-bare-item.rs @@ -1,5 +1,5 @@ fn f() { - #debug("This is a bare function"); + debug!{"This is a bare function"}; } fn main() { diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs index daa8106419c..442e9eb4e19 100644 --- a/src/test/run-pass/foreach-simple-outer-slot.rs +++ b/src/test/run-pass/foreach-simple-outer-slot.rs @@ -4,13 +4,13 @@ // -*- rust -*- fn main() { let mut sum: int = 0; - do first_ten |i| { #debug("main"); log(debug, i); sum = sum + i; } - #debug("sum"); + do first_ten |i| { debug!{"main"}; log(debug, i); sum = sum + i; } + debug!{"sum"}; log(debug, sum); assert (sum == 45); } fn first_ten(it: fn(int)) { let mut i: int = 0; - while i < 10 { #debug("first_ten"); it(i); i = i + 1; } + while i < 10 { debug!{"first_ten"}; it(i); i = i + 1; } } diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs index 37727bcf03a..5857d1ae421 100644 --- a/src/test/run-pass/generic-tag-alt.rs +++ b/src/test/run-pass/generic-tag-alt.rs @@ -4,7 +4,7 @@ enum foo<T> { arm(T), } fn altfoo<T>(f: foo<T>) { let mut hit = false; - alt f { arm::<T>(x) { #debug("in arm"); hit = true; } } + alt f { arm::<T>(x) { debug!{"in arm"}; hit = true; } } assert (hit); } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index a29fd7afc1d..80c942c69d1 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -49,9 +49,9 @@ mod map_reduce { some(_c) { c = _c } none { let p = port(); - #error("sending find_reducer"); + error!{"sending find_reducer"}; send(ctrl, find_reducer(str::bytes(key), chan(p))); - #error("receiving"); + error!{"receiving"}; c = recv(p); log(error, c); im.insert(key, c); diff --git a/src/test/run-pass/hello.rs b/src/test/run-pass/hello.rs index 018830de4c9..35ef6fbf695 100644 --- a/src/test/run-pass/hello.rs +++ b/src/test/run-pass/hello.rs @@ -2,4 +2,4 @@ // -*- rust -*- -fn main() { #debug("hello, world."); } +fn main() { debug!{"hello, world."}; } diff --git a/src/test/run-pass/iface-cast.rs b/src/test/run-pass/iface-cast.rs index b53a4c06ee9..ce1147dd176 100644 --- a/src/test/run-pass/iface-cast.rs +++ b/src/test/run-pass/iface-cast.rs @@ -27,8 +27,8 @@ impl of to_str for int { impl of to_str for Tree { 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()] + fmt!{"[%s, %s, %s]", self.val.to_str(), + l.to_str(), r.to_str()} } } diff --git a/src/test/run-pass/import-glob-0.rs b/src/test/run-pass/import-glob-0.rs index 1ea6ceae22c..0f830727768 100644 --- a/src/test/run-pass/import-glob-0.rs +++ b/src/test/run-pass/import-glob-0.rs @@ -5,10 +5,10 @@ mod module_of_many_things { export f1; export f2; export f4; - fn f1() { #debug("f1"); } - fn f2() { #debug("f2"); } - fn f3() { #debug("f3"); } - fn f4() { #debug("f4"); } + fn f1() { debug!{"f1"}; } + fn f2() { debug!{"f2"}; } + fn f3() { debug!{"f3"}; } + fn f4() { debug!{"f4"}; } } mod dug { @@ -17,8 +17,8 @@ mod dug { mod and { mod too { mod deep { - fn nameless_fear() { #debug("Boo!"); } - fn also_redstone() { #debug("Whatever."); } + fn nameless_fear() { debug!{"Boo!"}; } + fn also_redstone() { debug!{"Whatever."}; } } } } diff --git a/src/test/run-pass/import-glob-1.rs b/src/test/run-pass/import-glob-1.rs index 6415836988b..5ca7e028985 100644 --- a/src/test/run-pass/import-glob-1.rs +++ b/src/test/run-pass/import-glob-1.rs @@ -32,7 +32,7 @@ mod a2 { mod b2 { // | fn word_traveler() { // | - #debug("ahoy!"); // -/ + debug!{"ahoy!"}; // -/ } // } // } diff --git a/src/test/run-pass/import2.rs b/src/test/run-pass/import2.rs index 660f4f63147..8775f03f2e9 100644 --- a/src/test/run-pass/import2.rs +++ b/src/test/run-pass/import2.rs @@ -2,7 +2,7 @@ import zed::bar; mod zed { - fn bar() { #debug("bar"); } + fn bar() { debug!{"bar"}; } } fn main() { bar(); } diff --git a/src/test/run-pass/import3.rs b/src/test/run-pass/import3.rs index e4cddbe082f..95c68818412 100644 --- a/src/test/run-pass/import3.rs +++ b/src/test/run-pass/import3.rs @@ -4,7 +4,7 @@ import zed::bar; mod baz { mod zed { - fn bar() { #debug("bar2"); } + fn bar() { debug!{"bar2"}; } } } diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs index f6d2a9c9b5b..7df4ddbb71b 100644 --- a/src/test/run-pass/import4.rs +++ b/src/test/run-pass/import4.rs @@ -2,7 +2,7 @@ import zed::bar; mod zed { - fn bar() { #debug("bar"); } + fn bar() { debug!{"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 ef8df1b9399..bce048833c9 100644 --- a/src/test/run-pass/import5.rs +++ b/src/test/run-pass/import5.rs @@ -3,7 +3,7 @@ mod foo { import zed::bar; export bar; mod zed { - fn bar() { #debug("foo"); } + fn bar() { debug!{"foo"}; } } } diff --git a/src/test/run-pass/import6.rs b/src/test/run-pass/import6.rs index 65fec25afc5..2449b5c7273 100644 --- a/src/test/run-pass/import6.rs +++ b/src/test/run-pass/import6.rs @@ -2,7 +2,7 @@ import foo::zed; import bar::baz; mod foo { mod zed { - fn baz() { #debug("baz"); } + fn baz() { debug!{"baz"}; } } } mod bar { diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs index eeb8484e574..83923cce64d 100644 --- a/src/test/run-pass/import7.rs +++ b/src/test/run-pass/import7.rs @@ -2,7 +2,7 @@ import foo::zed; import bar::baz; mod foo { mod zed { - fn baz() { #debug("baz"); } + fn baz() { debug!{"baz"}; } } } mod bar { diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs index c6a843cde09..27a123c0c4e 100644 --- a/src/test/run-pass/inner-module.rs +++ b/src/test/run-pass/inner-module.rs @@ -4,7 +4,7 @@ // -*- rust -*- mod inner { mod inner2 { - fn hello() { #debug("hello, modular world"); } + fn hello() { debug!{"hello, modular world"}; } } fn hello() { inner2::hello(); } } diff --git a/src/test/run-pass/issue-1466.rs b/src/test/run-pass/issue-1466.rs index 15811ef26b6..d2a9368d9d8 100644 --- a/src/test/run-pass/issue-1466.rs +++ b/src/test/run-pass/issue-1466.rs @@ -2,6 +2,6 @@ // xfail-test 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-2101.rs b/src/test/run-pass/issue-2101.rs index f05269e29e9..6309e967db2 100644 --- a/src/test/run-pass/issue-2101.rs +++ b/src/test/run-pass/issue-2101.rs @@ -14,7 +14,7 @@ fn main(args: ~[str]) { let leak = init(&ar, args[0]); alt *leak { s(astr) { - io::println(#fmt("%?", astr)); + io::println(fmt!{"%?", astr}); } }; } diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs index b8531b68e2e..104ea37588b 100644 --- a/src/test/run-pass/issue-2185.rs +++ b/src/test/run-pass/issue-2185.rs @@ -44,5 +44,5 @@ fn main() { a); let sum = foldl(filt, 0u, |accum, &&n: uint| accum + n ); - io::println(#fmt("%u", sum)); + io::println(fmt!{"%u", sum}); } \ No newline at end of file diff --git a/src/test/run-pass/issue-2633.rs b/src/test/run-pass/issue-2633.rs index 53d7861be4f..d08a863529c 100644 --- a/src/test/run-pass/issue-2633.rs +++ b/src/test/run-pass/issue-2633.rs @@ -1,6 +1,6 @@ class cat { let mut meow: fn@(); - new() { self.meow = fn@() { #error("meow"); };} + new() { self.meow = fn@() { error!{"meow"}; };} } type kitty_info = {kitty: cat}; diff --git a/src/test/run-pass/issue-2804-2.rs b/src/test/run-pass/issue-2804-2.rs index 4ac9ea0eb6e..da7953a2370 100644 --- a/src/test/run-pass/issue-2804-2.rs +++ b/src/test/run-pass/issue-2804-2.rs @@ -4,7 +4,7 @@ use std; import std::map::hashmap; fn add_interfaces(managed_ip: ~str, device: std::map::hashmap<~str, int>) { - #error["%s, %?", managed_ip, device[~"interfaces"]]; + 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 926a8086cc2..811f5a52a14 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -19,7 +19,7 @@ fn lookup(table: std::map::hashmap<~str, std::json::json>, key: ~str, default: ~ } option::some(value) { - #error["%s was expected to be a string but is a %?", key, value]; + error!{"%s was expected to be a string but is a %?", key, value}; default } option::none @@ -36,13 +36,13 @@ fn add_interface(store: int, managed_ip: ~str, data: std::json::json) -> (~str, std::json::dict(interface) { let name = lookup(interface, ~"ifDescr", ~""); - let label = #fmt["%s-%s", managed_ip, name]; + let label = fmt!{"%s-%s", managed_ip, name}; (label, bool_value(false)) } _ { - #error["Expected dict for %s interfaces but found %?", managed_ip, data]; + error!{"Expected dict for %s interfaces but found %?", managed_ip, data}; (~"gnos:missing-interface", bool_value(true)) } } @@ -60,7 +60,7 @@ fn add_interfaces(store: int, managed_ip: ~str, device: std::map::hashmap<~str, } _ { - #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/issue-2834.rs b/src/test/run-pass/issue-2834.rs index f3ec64f7b5d..6942e585b44 100644 --- a/src/test/run-pass/issue-2834.rs +++ b/src/test/run-pass/issue-2834.rs @@ -12,7 +12,7 @@ fn rendezvous() { let (c, s) = streamp::init(); let streams: ~[streamp::client::open<int>] = ~[c]; - #error("%?", streams[0]); + error!{"%?", streams[0]}; } fn main(args: ~[str]) { diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs index 33422314883..9ffa90069b8 100644 --- a/src/test/run-pass/issue-687.rs +++ b/src/test/run-pass/issue-687.rs @@ -19,21 +19,21 @@ fn packager(cb: chan<chan<~[u8]>>, msg: chan<msg>) { let p: port<~[u8]> = port(); send(cb, chan(p)); loop { - #debug("waiting for bytes"); + debug!{"waiting for bytes"}; let data = recv(p); - #debug("got bytes"); + debug!{"got bytes"}; if vec::len(data) == 0u { - #debug("got empty bytes, quitting"); + debug!{"got empty bytes, quitting"}; break; } - #debug("sending non-empty buffer of length"); + debug!{"sending non-empty buffer of length"}; log(debug, vec::len(data)); send(msg, received(data)); - #debug("sent non-empty buffer"); + debug!{"sent non-empty buffer"}; } - #debug("sending closed message"); + debug!{"sending closed message"}; send(msg, closed); - #debug("sent closed message"); + debug!{"sent closed message"}; } fn main() { @@ -49,9 +49,9 @@ fn main() { loop { let msg = recv(p); alt msg { - closed { #debug("Got close message"); break; } + closed { debug!{"Got close message"}; break; } received(data) { - #debug("Got data. Length is:"); + debug!{"Got data. Length is:"}; log(debug, vec::len::<u8>(data)); } } diff --git a/src/test/run-pass/item-attributes.rs b/src/test/run-pass/item-attributes.rs index c98a3003177..e0b7a294a6c 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/lazychan.rs b/src/test/run-pass/lazychan.rs index cbdd1e9aabf..8f5bffebf21 100644 --- a/src/test/run-pass/lazychan.rs +++ b/src/test/run-pass/lazychan.rs @@ -11,13 +11,13 @@ fn main() { task::spawn(|| child(ch) ); y = recv(p); - #debug("received 1"); + debug!{"received 1"}; log(debug, y); assert (y == 10); task::spawn(|| child(ch) ); y = recv(p); - #debug("received 2"); + debug!{"received 2"}; log(debug, y); assert (y == 10); } diff --git a/src/test/run-pass/leaky_comm.rs b/src/test/run-pass/leaky_comm.rs index fe4f44caf08..58a655917ba 100644 --- a/src/test/run-pass/leaky_comm.rs +++ b/src/test/run-pass/leaky_comm.rs @@ -10,10 +10,10 @@ fn main() { none {} some(_) { if test_comm::recv(p) == 0 { - #error("floop"); + error!{"floop"}; } else { - #error("bloop"); + error!{"bloop"}; } }} } \ No newline at end of file diff --git a/src/test/run-pass/liveness-loop-break.rs b/src/test/run-pass/liveness-loop-break.rs index cec9c25e67a..b66e6aa15e5 100644 --- a/src/test/run-pass/liveness-loop-break.rs +++ b/src/test/run-pass/liveness-loop-break.rs @@ -4,7 +4,7 @@ fn test() { v = 3; break; } - #debug["%d", v]; + debug!{"%d", v}; } fn main() { 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 57542570860..8f24404fed7 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 @@ -7,12 +7,12 @@ enum foo { } fn check_log<T>(exp: ~str, v: T) { - assert exp == #fmt["%?", v]; + assert exp == fmt!{"%?", v}; } fn main() { let x = list::from_vec(~[a(22u), b(~"hi")]); let exp = ~"@cons(a(22), @cons(b(~\"hi\"), @nil))"; - assert #fmt["%?", x] == exp; + 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 f2d066277d4..bca729e6538 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 @@ -5,7 +5,7 @@ enum foo { } 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 5f406d5fbbf..c5b44343116 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 fmt!{"%?/%6?", ~[1, 2, 3], ~"hi"} == ~"~[1, 2, 3]/ ~\"hi\""; } diff --git a/src/test/run-pass/macro-2.rs b/src/test/run-pass/macro-2.rs index c1b20f650e5..509238e7e48 100644 --- a/src/test/run-pass/macro-2.rs +++ b/src/test/run-pass/macro-2.rs @@ -7,7 +7,7 @@ fn main() { f }]]; - assert (#mylambda[y, y * 2](8) == 16); + assert (mylambda!{y, y * 2}(8) == 16); macro_rules! mylambda_tt{ {$x:ident, $body:expr} => { diff --git a/src/test/run-pass/macro-3.rs b/src/test/run-pass/macro-3.rs index 891d5a498b2..63dc2a7a5b0 100644 --- a/src/test/run-pass/macro-3.rs +++ b/src/test/run-pass/macro-3.rs @@ -3,7 +3,7 @@ fn main() { #macro[[#trivial[], 1 * 2 * 4 * 2 * 1]]; - assert (#trivial[] == 16); + assert (trivial!{} == 16); macro_rules! trivial_tt{ {} => {1*2*4*2*1} diff --git a/src/test/run-pass/macro-by-example-1.rs b/src/test/run-pass/macro-by-example-1.rs index 568739b0663..cafffee566e 100644 --- a/src/test/run-pass/macro-by-example-1.rs +++ b/src/test/run-pass/macro-by-example-1.rs @@ -9,7 +9,7 @@ fn main() { fn add(a: int, b: int) -> int { ret a + b; } - assert(#apply[add, [1, 15]] == 16); + assert(apply!{add, [1, 15]} == 16); assert(apply!{add, [1, 15]} == 16); assert(apply_tt!{add, (1, 15)} == 16); } diff --git a/src/test/run-pass/macro-by-example-2.rs b/src/test/run-pass/macro-by-example-2.rs index 8f39817d0c3..eda697156a9 100644 --- a/src/test/run-pass/macro-by-example-2.rs +++ b/src/test/run-pass/macro-by-example-2.rs @@ -7,22 +7,22 @@ fn main() { [#zip_or_unzip[[xx, yy], ...], [[xx, ...], [yy, ...]]]]; - assert (#zip_or_unzip[[1, 2, 3, 4], [5, 6, 7, 8]] == + assert (zip_or_unzip!{[1, 2, 3, 4], [5, 6, 7, 8]} == [[1, 5], [2, 6], [3, 7], [4, 8]]); - assert (#zip_or_unzip[[1, 5], [2, 6], [3, 7], [4, 8]] == + assert (zip_or_unzip!{[1, 5], [2, 6], [3, 7], [4, 8]} == [[1, 2, 3, 4], [5, 6, 7, 8]]); #macro[[#nested[[[x, ...], ...], [[y, ...], ...]], [[[x, y], ...], ...]]]; - assert (#nested[[[1, 2, 3, 4, 5], [7, 8, 9, 10, 11, 12]], - [[-1, -2, -3, -4, -5], [-7, -8, -9, -10, -11, -12]]] == + assert (nested!{[[1, 2, 3, 4, 5], [7, 8, 9, 10, 11, 12]], + [[-1, -2, -3, -4, -5], [-7, -8, -9, -10, -11, -12]]} == [[[1, -1], [2, -2], [3, -3], [4, -4], [5, -5]], [[7, -7], [8, -8], [9, -9], [10, -10], [11, -11], [12, -12]]]); #macro[[#dup[y, [x, ...]], [[y, x], ...]]]; - assert (#dup[1, [1, 2, 3, 4]] == [[1, 1], [1, 2], [1, 3], [1, 4]]); + assert (dup!{1, [1, 2, 3, 4]} == [[1, 1], [1, 2], [1, 3], [1, 4]]); #macro[[#lambda[x, #<t>, body, #<s>], @@ -32,19 +32,19 @@ fn main() { }]]; - assert (#lambda[i, #<uint>, i + 4u, #<uint>](12u) == 16u); + assert (lambda!{i, #<uint>, i + 4u, #<uint>}(12u) == 16u); #macro[[#sum[x, xs, ...], x + #sum[xs, ...]], [#sum[], 0]]; - assert (#sum[1, 2, 3, 4] == 10); + assert (sum!{1, 2, 3, 4} == 10); #macro[[#transcr_mixed[a, as, ...], #sum[6, as, ...] * a]]; - assert (#transcr_mixed[10, 5, 4, 3, 2, 1] == 210); + assert (transcr_mixed!{10, 5, 4, 3, 2, 1} == 210); #macro[[#surround[pre, [xs, ...], post], [pre, xs, ..., post]]]; - assert (#surround[1, [2, 3, 4], 5] == [1, 2, 3, 4, 5]); + assert (surround!{1, [2, 3, 4], 5} == [1, 2, 3, 4, 5]); } diff --git a/src/test/run-pass/macro.rs b/src/test/run-pass/macro.rs index 0f4350c5d8e..564af959d89 100644 --- a/src/test/run-pass/macro.rs +++ b/src/test/run-pass/macro.rs @@ -2,7 +2,7 @@ fn main() { #macro[[#m1[a], a * 4]]; - assert (#m1[2] == 8); + assert (m1!{2} == 8); macro_rules! m1tt { {$a:expr} => {$a*4} diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs index 9083e1841c7..bdecc4b4f98 100644 --- a/src/test/run-pass/many.rs +++ b/src/test/run-pass/many.rs @@ -21,7 +21,7 @@ fn main() { let ch = comm::chan(p); let child = task::spawn(|| sub(ch, 200) ); let y = comm::recv(p); - #debug("transmission complete"); + debug!{"transmission complete"}; log(debug, y); assert (y == 200); } diff --git a/src/test/run-pass/max-min-classes.rs b/src/test/run-pass/max-min-classes.rs index 61e4bc047f4..939dcbdbb17 100644 --- a/src/test/run-pass/max-min-classes.rs +++ b/src/test/run-pass/max-min-classes.rs @@ -25,6 +25,6 @@ fn Foo(x: int, y: int) -> Foo { fn main() { let foo = Foo(3, 20); - io::println(#fmt("%d %d", foo.sum(), foo.product())); + io::println(fmt!{"%d %d", foo.sum(), foo.product()}); } diff --git a/src/test/run-pass/multi-src/bar.rs b/src/test/run-pass/multi-src/bar.rs index f851522bf52..54b264dc162 100644 --- a/src/test/run-pass/multi-src/bar.rs +++ b/src/test/run-pass/multi-src/bar.rs @@ -1,3 +1,3 @@ -fn other() { #debug("yes"); } +fn other() { debug!{"yes"}; } diff --git a/src/test/run-pass/multi-src/foo.rs b/src/test/run-pass/multi-src/foo.rs index 9f12fd12c6e..3ea6f019efa 100644 --- a/src/test/run-pass/multi-src/foo.rs +++ b/src/test/run-pass/multi-src/foo.rs @@ -1,3 +1,3 @@ -fn main() { #debug("hello, multi-file world."); bar::other(); } +fn main() { debug!{"hello, multi-file world."}; bar::other(); } diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs index b0493b32c1e..935b82ada56 100644 --- a/src/test/run-pass/nested-alts.rs +++ b/src/test/run-pass/nested-alts.rs @@ -8,7 +8,7 @@ fn foo() { alt none::<int> { none::<int> { bar = 5; } _ { baz(); } } log(debug, bar); } - none::<int> { #debug("hello"); } + none::<int> { debug!{"hello"}; } } } diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs index 6eda8f11489..e47a8cad54c 100644 --- a/src/test/run-pass/nested-pattern.rs +++ b/src/test/run-pass/nested-pattern.rs @@ -10,8 +10,8 @@ enum t { foo(int, uint), bar(int, option<int>), } fn nested(o: t) { alt o { - bar(i, some::<int>(_)) { #error("wrong pattern matched"); fail; } - _ { #error("succeeded"); } + bar(i, some::<int>(_)) { error!{"wrong pattern matched"}; fail; } + _ { error!{"succeeded"}; } } } diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs index f277498201d..e06997c671d 100644 --- a/src/test/run-pass/paren-free.rs +++ b/src/test/run-pass/paren-free.rs @@ -1,5 +1,5 @@ fn main() { let x = true; if x { let mut i = 10; while i > 0 { i -= 1; } } - alt x { true { #debug("right"); } false { #debug("wrong"); } } + alt x { true { debug!{"right"}; } false { debug!{"wrong"}; } } } diff --git a/src/test/run-pass/pipe-detect-term.rs b/src/test/run-pass/pipe-detect-term.rs index 92467009365..93b919154db 100644 --- a/src/test/run-pass/pipe-detect-term.rs +++ b/src/test/run-pass/pipe-detect-term.rs @@ -38,7 +38,7 @@ fn failtest() { fail; } - #error("%?", recv(p)); + error!{"%?", recv(p)}; // make sure we get killed if we missed it in the receive. loop { task::yield() } } diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index 056b0cb477a..04cde9c742e 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -26,26 +26,26 @@ fn main() { let iotask = uv::global_loop::get(); let c = pipes::spawn_service(stream::init, |p| { - #error("waiting for pipes"); + error!{"waiting for pipes"}; let stream::send(x, p) = recv(p); - #error("got pipes"); + error!{"got pipes"}; let (left, right) : (oneshot::server::waiting, oneshot::server::waiting) = x; - #error("selecting"); + error!{"selecting"}; let (i, _, _) = select(~[left, right]); - #error("selected"); + error!{"selected"}; assert i == 0; - #error("waiting for pipes"); + error!{"waiting for pipes"}; let stream::send(x, _) = recv(p); - #error("got pipes"); + error!{"got pipes"}; let (left, right) : (oneshot::server::waiting, oneshot::server::waiting) = x; - #error("selecting"); + error!{"selecting"}; let (i, m, _) = select(~[left, right]); - #error("selected %?", i); + error!{"selected %?", i}; if m != none { assert i == 1; } @@ -85,7 +85,7 @@ fn test_select2() { stream::client::send(bc, ~"abc"); - #error("done with first select2"); + error!{"done with first select2"}; let (ac, ap) = stream::init(); let (bc, bp) = stream::init(); diff --git a/src/test/run-pass/placement-new-arena.rs b/src/test/run-pass/placement-new-arena.rs index a7bec465738..e3750c15417 100644 --- a/src/test/run-pass/placement-new-arena.rs +++ b/src/test/run-pass/placement-new-arena.rs @@ -4,6 +4,6 @@ import std::arena::arena; fn main() { let p = &arena(); let x = new(*p) 4u; - io::print(#fmt["%u", *x]); + io::print(fmt!{"%u", *x}); assert *x == 4u; } diff --git a/src/test/run-pass/placement-new-leaky.rs b/src/test/run-pass/placement-new-leaky.rs index 85363c432e0..96e56a7d8e5 100644 --- a/src/test/run-pass/placement-new-leaky.rs +++ b/src/test/run-pass/placement-new-leaky.rs @@ -19,7 +19,7 @@ impl methods for malloc_pool { fn main() { let p = &malloc_pool(()); let x = new(*p) 4u; - io::print(#fmt["%u", *x]); + io::print(fmt!{"%u", *x}); assert *x == 4u; unsafe { libc::free(unsafe::reinterpret_cast(x)); diff --git a/src/test/run-pass/preempt.rs b/src/test/run-pass/preempt.rs index 3b538644976..5d53731698e 100644 --- a/src/test/run-pass/preempt.rs +++ b/src/test/run-pass/preempt.rs @@ -2,21 +2,21 @@ // This checks that preemption works. fn starve_main(alive: chan<int>) { - #debug("signalling main"); + debug!{"signalling main"}; alive <| 1; - #debug("starving main"); + debug!{"starving main"}; let i: int = 0; loop { i += 1; } } fn main() { let alive: port<int> = port(); - #debug("main started"); + debug!{"main started"}; let s: task = spawn starve_main(chan(alive)); let i: int; - #debug("main waiting for alive signal"); + debug!{"main waiting for alive signal"}; alive |> i; - #debug("main got alive signal"); - while i < 50 { #debug("main iterated"); i += 1; } - #debug("main completed"); + debug!{"main got alive signal"}; + while i < 50 { debug!{"main iterated"}; i += 1; } + debug!{"main completed"}; } diff --git a/src/test/run-pass/pure-fmt.rs b/src/test/run-pass/pure-fmt.rs index 47af01d5b16..d5c9b27fdf2 100644 --- a/src/test/run-pass/pure-fmt.rs +++ b/src/test/run-pass/pure-fmt.rs @@ -9,12 +9,12 @@ pure fn foo() { f: 0.0, g: true }; - #debug("test %?", a.b); - #debug("test %u", a.c); - #debug("test %i", a.d); - #debug("test %c", a.e); - #debug("test %f", a.f); - #debug("test %b", a.g); + debug!{"test %?", a.b}; + debug!{"test %u", a.c}; + debug!{"test %i", a.d}; + debug!{"test %c", a.e}; + debug!{"test %f", a.f}; + debug!{"test %b", a.g}; } fn main() { diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs index 8624e5682a8..d9cd2640b4d 100644 --- a/src/test/run-pass/rcvr-borrowed-to-region.rs +++ b/src/test/run-pass/rcvr-borrowed-to-region.rs @@ -18,21 +18,21 @@ fn main() { let x = @6; let y = x.get(); - #debug["y=%d", y]; + debug!{"y=%d", y}; assert y == 6; let x = ~mut 6; let y = x.get(); - #debug["y=%d", y]; + debug!{"y=%d", y}; assert y == 6; let x = ~6; let y = x.get(); - #debug["y=%d", y]; + debug!{"y=%d", y}; assert y == 6; let x = &6; let y = x.get(); - #debug["y=%d", y]; + debug!{"y=%d", y}; assert y == 6; } diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs index 10f91de8615..9a9dcfb21e6 100644 --- a/src/test/run-pass/rcvr-borrowed-to-slice.rs +++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs @@ -16,16 +16,16 @@ fn call_sum(x: &[int]) -> int { x.sum() } fn main() { let x = ~[1, 2, 3]; let y = call_sum(x); - #debug["y==%d", y]; + debug!{"y==%d", y}; assert y == 6; let x = ~[mut 1, 2, 3]; let y = x.sum(); - #debug["y==%d", y]; + debug!{"y==%d", y}; assert y == 6; let x = ~[1, 2, 3]; let y = x.sum(); - #debug["y==%d", y]; + debug!{"y==%d", y}; assert y == 6; } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 81f11395e04..8dc326265d9 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -37,11 +37,11 @@ fn main() { let x = {c8: 22u8, t: {c64: 44u32}}; // Send it through the shape code - let y = #fmt["%?", x]; + let y = fmt!{"%?", x}; - #debug("align inner = %?", rusti::min_align_of::<inner>()); - #debug("size outer = %?", sys::size_of::<outer>()); - #debug("y = %s", y); + debug!{"align inner = %?", rusti::min_align_of::<inner>()}; + debug!{"size outer = %?", sys::size_of::<outer>()}; + debug!{"y = %s", y}; // per clang/gcc the alignment of `inner` is 4 on x86. assert rusti::min_align_of::<inner>() == m::align(); diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 433ca581ab3..c4a1b1b6a70 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -51,11 +51,11 @@ fn main() { let x = {c8: 22u8, t: {c64: 44u64}}; // Send it through the shape code - let y = #fmt["%?", x]; + let y = fmt!{"%?", x}; - #debug("align inner = %?", rusti::min_align_of::<inner>()); - #debug("size outer = %?", sys::size_of::<outer>()); - #debug("y = %s", y); + debug!{"align inner = %?", rusti::min_align_of::<inner>()}; + debug!{"size outer = %?", sys::size_of::<outer>()}; + debug!{"y = %s", y}; // per clang/gcc the alignment of `inner` is 4 on x86. assert rusti::min_align_of::<inner>() == m::m::align(); diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index 3dfd78b2025..356be35b1f8 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -543,7 +543,7 @@ impl of ty_visitor for my_visitor { _sz: uint, _align: uint) -> bool { true } fn visit_rec_field(_i: uint, _name: &str, _mtbl: uint, inner: *tydesc) -> bool { - #error("rec field!"); + error!{"rec field!"}; self.visit_inner(inner) } fn visit_leave_rec(_n_fields: uint, @@ -561,7 +561,7 @@ impl of ty_visitor for my_visitor { fn visit_enter_tup(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } fn visit_tup_field(_i: uint, inner: *tydesc) -> bool { - #error("tup field!"); + error!{"tup field!"}; self.visit_inner(inner) } fn visit_leave_tup(_n_fields: uint, @@ -617,14 +617,14 @@ fn main() { mut vals: ~[]}); let v = ptr_visit_adaptor({inner: u}); let td = get_tydesc_for(r); - unsafe { #error("tydesc sz: %u, align: %u", - (*td).size, (*td).align); } + unsafe { error!{"tydesc sz: %u, align: %u", + (*td).size, (*td).align}; } let v = v as ty_visitor; visit_tydesc(td, v); for (copy u.vals).each |s| { - io::println(#fmt("val: %s", s)); + io::println(fmt!{"val: %s", s}); } - #error("%?", copy u.vals); + error!{"%?", copy u.vals}; 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 87f64c17e17..b0ab99253c1 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -7,32 +7,32 @@ enum my_visitor = @{ mut types: ~[str] }; impl of ty_visitor for my_visitor { fn visit_bot() -> bool { self.types += ["bot"]; - #error("visited bot type"); + error!{"visited bot type"}; true } fn visit_nil() -> bool { self.types += ["nil"]; - #error("visited nil type"); + error!{"visited nil type"}; true } fn visit_bool() -> bool { self.types += ["bool"]; - #error("visited bool type"); + error!{"visited bool type"}; true } fn visit_int() -> bool { self.types += ["int"]; - #error("visited int type"); + error!{"visited int type"}; true } fn visit_i8() -> bool { self.types += ["i8"]; - #error("visited i8 type"); + error!{"visited i8 type"}; true } fn visit_i16() -> bool { self.types += ["i16"]; - #error("visited i16 type"); + error!{"visited i16 type"}; true } fn visit_i32() -> bool { true } @@ -143,7 +143,7 @@ fn main() { visit_ty::<~[int]>(vv); for (copy v.types).each {|s| - io::println(#fmt("type: %s", s)); + io::println(fmt!{"type: %s", s}); } assert v.types == ["bool", "int", "i8", "i16", "[", "int", "]"]; diff --git a/src/test/run-pass/regions-addr-of-ret.rs b/src/test/run-pass/regions-addr-of-ret.rs index d9571ab7c40..f4e1221e3db 100644 --- a/src/test/run-pass/regions-addr-of-ret.rs +++ b/src/test/run-pass/regions-addr-of-ret.rs @@ -4,6 +4,6 @@ fn f(x : &a/int) -> &a/int { fn main() { let three = &3; - log(error, #fmt("%d", *f(three))); + log(error, fmt!{"%d", *f(three)}); } diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs index 18c7222dfa6..a717f325f6a 100644 --- a/src/test/run-pass/regions-borrow-at.rs +++ b/src/test/run-pass/regions-borrow-at.rs @@ -5,6 +5,6 @@ fn foo(x: &uint) -> uint { fn main() { let p = @22u; let r = foo(p); - #debug["r=%u", r]; + debug!{"r=%u", r}; assert r == 22u; } diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs index a20d18ea61e..2adcae2c5c3 100644 --- a/src/test/run-pass/resource-cycle.rs +++ b/src/test/run-pass/resource-cycle.rs @@ -4,16 +4,16 @@ class r { let v: *int; new(v: *int) unsafe { self.v = v; - #debug("r's ctor: v = %x, self = %x, self.v = %x", + debug!{"r's ctor: v = %x, self = %x, self.v = %x", unsafe::reinterpret_cast::<*int, uint>(v), unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(self)), - unsafe::reinterpret_cast::<**int, uint>(ptr::addr_of(self.v))); + unsafe::reinterpret_cast::<**int, uint>(ptr::addr_of(self.v))}; } drop unsafe { - #debug("r's dtor: self = %x, self.v = %x, self.v's value = %x", + debug!{"r's dtor: self = %x, self.v = %x, self.v's value = %x", unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(self)), unsafe::reinterpret_cast::<**int, uint>(ptr::addr_of(self.v)), - unsafe::reinterpret_cast::<*int, uint>(self.v)); + unsafe::reinterpret_cast::<*int, uint>(self.v)}; let v2: ~int = unsafe::reinterpret_cast(self.v); } } @@ -34,28 +34,28 @@ fn main() unsafe { mut next: none, r: { let rs = r(i1p); - #debug("r = %x", - unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))); + debug!{"r = %x", + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))}; rs } }); - #debug("x1 = %x, x1.r = %x", + debug!{"x1 = %x, x1.r = %x", unsafe::reinterpret_cast::<@t, uint>(x1), - unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x1.r))); + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x1.r))}; let x2 = @t({ mut next: none, r: { let rs = r(i2p); - #debug("r2 = %x", - unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))); + debug!{"r2 = %x", + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))}; rs } }); - #debug("x2 = %x, x2.r = %x", + debug!{"x2 = %x, x2.r = %x", unsafe::reinterpret_cast::<@t, uint>(x2), - unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x2.r))); + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x2.r))}; x1.next = some(x2); x2.next = some(x1); diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs index 3ccf15c9daf..9565f7691e9 100644 --- a/src/test/run-pass/resource-destruct.rs +++ b/src/test/run-pass/resource-destruct.rs @@ -8,6 +8,6 @@ class shrinky_pointer { fn main() { let my_total = @@mut 10; { let pt <- shrinky_pointer(my_total); assert (pt.look_at() == 10); } - log(error, #fmt("my_total = %d", **my_total)); + log(error, fmt!{"my_total = %d", **my_total}); assert (**my_total == 9); } diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs index a30b1964bda..fb53463d5be 100644 --- a/src/test/run-pass/rt-sched-1.rs +++ b/src/test/run-pass/rt-sched-1.rs @@ -19,15 +19,15 @@ fn main() unsafe { let po = comm::port(); let ch = comm::chan(po); let parent_sched_id = rustrt::rust_get_sched_id(); - #error("parent %?", parent_sched_id); + error!{"parent %?", parent_sched_id}; let num_threads = 1u; let new_sched_id = rustrt::rust_new_sched(num_threads); - #error("new_sched_id %?", new_sched_id); + error!{"new_sched_id %?", new_sched_id}; let new_task_id = rustrt::rust_new_task_in_sched(new_sched_id); assert !new_task_id.is_null(); let f = fn~() { let child_sched_id = rustrt::rust_get_sched_id(); - #error("child_sched_id %?", child_sched_id); + error!{"child_sched_id %?", child_sched_id}; assert child_sched_id != parent_sched_id; assert child_sched_id == new_sched_id; comm::send(ch, ()); diff --git a/src/test/run-pass/simple-alt-generic-tag.rs b/src/test/run-pass/simple-alt-generic-tag.rs index 3b1e1811ba8..43ba568fb08 100644 --- a/src/test/run-pass/simple-alt-generic-tag.rs +++ b/src/test/run-pass/simple-alt-generic-tag.rs @@ -4,5 +4,5 @@ enum opt<T> { none, } fn main() { let x = none::<int>; - alt x { none::<int> { #debug("hello world"); } } + alt x { none::<int> { debug!{"hello world"}; } } } diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs index b52ecafdebe..c4689f0951a 100644 --- a/src/test/run-pass/size-and-align.rs +++ b/src/test/run-pass/size-and-align.rs @@ -6,8 +6,8 @@ enum clam<T> { a(T, int), b, } fn uhoh<T>(v: ~[clam<T>]) { alt v[1] { - a::<T>(t, u) { #debug("incorrect"); log(debug, u); fail; } - b::<T> { #debug("correct"); } + a::<T>(t, u) { debug!{"incorrect"}; log(debug, u); fail; } + b::<T> { debug!{"correct"}; } } } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index 2f749ca8275..c0cbd0a5639 100644 --- a/src/test/run-pass/spawn-fn.rs +++ b/src/test/run-pass/spawn-fn.rs @@ -14,5 +14,5 @@ fn main() { 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(); } + while i > 0 { i = i - 1; debug!{"parent sleeping"}; yield(); } } diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs index 34108f30f2d..33579fc3d04 100644 --- a/src/test/run-pass/struct-return.rs +++ b/src/test/run-pass/struct-return.rs @@ -13,10 +13,10 @@ fn test1() { c: 0xcccc_cccc_cccc_cccc_u64, d: 0xdddd_dddd_dddd_dddd_u64 }; let qq = rustrt::debug_abi_1(q); - #error("a: %x", qq.a as uint); - #error("b: %x", qq.b as uint); - #error("c: %x", qq.c as uint); - #error("d: %x", qq.d as uint); + error!{"a: %x", qq.a as uint}; + error!{"b: %x", qq.b as uint}; + error!{"c: %x", qq.c as uint}; + error!{"d: %x", qq.d as uint}; assert qq.a == q.c + 1u64; assert qq.b == q.d - 1u64; assert qq.c == q.a + 1u64; @@ -29,9 +29,9 @@ fn test2() { b: 0b_1010_1010_u8, c: 1.0987654321e-15_f64 }; let ff = rustrt::debug_abi_2(f); - #error("a: %f", ff.a as float); - #error("b: %u", ff.b as uint); - #error("c: %f", ff.c as float); + error!{"a: %f", ff.a as float}; + error!{"b: %u", ff.b as uint}; + error!{"c: %f", ff.c as float}; assert ff.a == f.c + 1.0f64; assert ff.b == 0xff_u8; assert ff.c == f.a - 1.0f64; diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index eee76140ede..34d03677be4 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -8,10 +8,10 @@ fn test(actual: ~str, expected: ~str) { } fn main() { - test(#fmt["hello %d friends and %s things", 10, ~"formatted"], + 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"]; + let s = fmt!{"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 346a85ada0e..fd1cfc865c4 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] == ~"<.<"); + assert (concat_idents!{asd, f_f, dsa} == ~"<.<"); - assert (#ident_to_str[use_mention_distinction] == + assert (ident_to_str!{use_mention_distinction} == ~"use_mention_distinction"); } diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 582b1d9a7d3..4f8fa28227d 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -3,23 +3,23 @@ mod m1 { mod m2 { - fn where_am_i() -> ~str { #module[] } + fn where_am_i() -> ~str { module!{} } } } 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(#include["syntax-extension-source-utils-files/includeme.fragment"] + assert(line!{} == 11u); + assert(col!{} == 11u); + 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"); assert( - #include_str["syntax-extension-source-utils-files/includeme.fragment"] + include_str!{"syntax-extension-source-utils-files/includeme.fragment"} .starts_with(~"/* this is for ")); assert( - #include_bin["syntax-extension-source-utils-files/includeme.fragment"] + 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")); diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index 18084aecab2..6753dc54590 100644 --- a/src/test/run-pass/tag-align-shape.rs +++ b/src/test/run-pass/tag-align-shape.rs @@ -13,7 +13,7 @@ type t_rec = { fn main() { let x = {c8: 22u8, t: a_tag(44u64)}; - let y = #fmt["%?", x]; - #debug["y = %s", y]; + let y = fmt!{"%?", x}; + debug!{"y = %s", y}; assert y == "(22, a_tag(44))"; } diff --git a/src/test/run-pass/tag-auto-disr-val-shape.rs b/src/test/run-pass/tag-auto-disr-val-shape.rs index 89b79706079..645a58d33e1 100644 --- a/src/test/run-pass/tag-auto-disr-val-shape.rs +++ b/src/test/run-pass/tag-auto-disr-val-shape.rs @@ -2,8 +2,8 @@ enum color { red, green, blue, black, white, } fn main() { // Ideally we would print the name of the variant, not the number - assert (uint::to_str(red as uint, 10u) == #fmt["%?", red]); - assert (uint::to_str(green as uint, 10u) == #fmt["%?", green]); - assert (uint::to_str(white as uint, 10u) == #fmt["%?", white]); + assert (uint::to_str(red as uint, 10u) == fmt!{"%?", red}); + assert (uint::to_str(green as uint, 10u) == fmt!{"%?", green}); + assert (uint::to_str(white as uint, 10u) == fmt!{"%?", white}); } diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs index 8f48df6c266..7957dde5753 100644 --- a/src/test/run-pass/tag-disr-val-shape.rs +++ b/src/test/run-pass/tag-disr-val-shape.rs @@ -7,8 +7,8 @@ enum color { } fn main() { - assert uint::to_str(red as uint, 10u) == #fmt["%?", red]; - assert uint::to_str(green as uint, 10u) == #fmt["%?", green]; - assert uint::to_str(white as uint, 10u) == #fmt["%?", white]; + assert uint::to_str(red as uint, 10u) == fmt!{"%?", red}; + assert uint::to_str(green as uint, 10u) == fmt!{"%?", green}; + assert uint::to_str(white as uint, 10u) == fmt!{"%?", white}; } diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs index c2d38c67aaf..88344eb3174 100644 --- a/src/test/run-pass/tail-cps.rs +++ b/src/test/run-pass/tail-cps.rs @@ -7,13 +7,13 @@ fn checktrue(rs: bool) -> bool { assert (rs); ret true; } fn main() { let k = checktrue; evenk(42, k); oddk(45, k); } fn evenk(n: int, k: extern fn(bool) -> bool) -> bool { - #debug("evenk"); + debug!{"evenk"}; log(debug, n); if n == 0 { ret k(true); } else { ret oddk(n - 1, k); } } fn oddk(n: int, k: extern fn(bool) -> bool) -> bool { - #debug("oddk"); + debug!{"oddk"}; log(debug, n); if n == 0 { ret k(false); } else { ret evenk(n - 1, k); } } diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index eb866ee7b3e..94aded889bf 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -9,11 +9,11 @@ fn main() { test05(); } fn test05_start(ch : chan<int>) { ch.send(10); - #error("sent 10"); + error!{"sent 10"}; ch.send(20); - #error("sent 20"); + error!{"sent 20"}; ch.send(30); - #error("sent 30"); + error!{"sent 30"}; } fn test05() { diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs index ae0a39862d5..40ee4753bdd 100644 --- a/src/test/run-pass/task-comm-1.rs +++ b/src/test/run-pass/task-comm-1.rs @@ -1,8 +1,8 @@ fn main() { test00(); } -fn start() { #debug("Started / Finished task."); } +fn start() { debug!{"Started / Finished task."}; } fn test00() { task::try(|| start() ); - #debug("Completing."); + debug!{"Completing."}; } diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs index 60223dc1622..53d8ede2240 100644 --- a/src/test/run-pass/task-comm-12.rs +++ b/src/test/run-pass/task-comm-12.rs @@ -3,7 +3,7 @@ import task; fn main() { test00(); } -fn start(&&task_number: int) { #debug("Started / Finished task."); } +fn start(&&task_number: int) { debug!{"Started / Finished task."}; } fn test00() { let i: int = 0; @@ -22,5 +22,5 @@ fn test00() { // Try joining tasks that have already finished. future::get(option::unwrap(result)); - #debug("Joined task."); + debug!{"Joined task."}; } diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index 88220437c43..394bb256184 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -9,8 +9,8 @@ fn start(c: pipes::chan<int>, start: int, number_of_messages: int) { } fn main() { - #debug("Check that we don't deadlock."); + debug!{"Check that we don't deadlock."}; let (ch, p) = pipes::stream(); task::try(|| start(ch, 0, 10) ); - #debug("Joined task"); + debug!{"Joined task"}; } diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index 268b6d06dfd..0e0bf640014 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -23,7 +23,7 @@ fn main() { i = i - 1; } - #debug("main thread exiting"); + debug!{"main thread exiting"}; } fn child(x: int, ch: pipes::chan<int>) { diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index 05c057d85fd..c68ee5a2a0c 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -5,24 +5,24 @@ import pipes::chan; import pipes::send; import pipes::recv; -fn main() { #debug("===== WITHOUT THREADS ====="); test00(); } +fn main() { debug!{"===== WITHOUT THREADS ====="}; test00(); } fn test00_start(ch: chan<int>, message: int, count: int) { - #debug("Starting test00_start"); + debug!{"Starting test00_start"}; let mut i: int = 0; while i < count { - #debug("Sending Message"); + debug!{"Sending Message"}; ch.send(message + 0); i = i + 1; } - #debug("Ending test00_start"); + debug!{"Ending test00_start"}; } fn test00() { let number_of_tasks: int = 16; let number_of_messages: int = 4; - #debug("Creating tasks"); + debug!{"Creating tasks"}; let po = pipes::port_set(); @@ -54,7 +54,7 @@ fn test00() { // Join spawned tasks... for results.each |r| { future::get(r); } - #debug("Completed: Final number is: "); + debug!{"Completed: Final number is: "}; log(error, sum); // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * // number_of_messages)); diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs index 6f6d00da473..d66dbd26694 100644 --- a/src/test/run-pass/task-comm.rs +++ b/src/test/run-pass/task-comm.rs @@ -18,20 +18,20 @@ fn main() { } fn test00_start(ch: chan<int>, message: int, count: int) { - #debug("Starting test00_start"); + debug!{"Starting test00_start"}; let mut i: int = 0; while i < count { - #debug("Sending Message"); + debug!{"Sending Message"}; send(ch, message + 0); i = i + 1; } - #debug("Ending test00_start"); + debug!{"Ending test00_start"}; } fn test00() { let number_of_tasks: int = 1; let number_of_messages: int = 4; - #debug("Creating tasks"); + debug!{"Creating tasks"}; let po = port(); let ch = chan(po); @@ -55,7 +55,7 @@ fn test00() { for results.each |r| { future::get(r); } - #debug("Completed: Final number is: "); + debug!{"Completed: Final number is: "}; assert (sum == number_of_messages * (number_of_tasks * number_of_tasks + number_of_tasks) / @@ -64,7 +64,7 @@ fn test00() { fn test01() { let p = port(); - #debug("Reading from a port that is never written to."); + debug!{"Reading from a port that is never written to."}; let value: int = recv(p); log(debug, value); } @@ -72,25 +72,25 @@ fn test01() { fn test02() { let p = port(); let c = chan(p); - #debug("Writing to a local task channel."); + debug!{"Writing to a local task channel."}; send(c, 42); - #debug("Reading from a local task port."); + debug!{"Reading from a local task port."}; let value: int = recv(p); log(debug, value); } fn test04_start() { - #debug("Started task"); + debug!{"Started task"}; let mut i: int = 1024 * 1024; while i > 0 { i = i - 1; } - #debug("Finished task"); + debug!{"Finished task"}; } fn test04() { - #debug("Spawning lots of tasks."); + debug!{"Spawning lots of tasks."}; let mut i: int = 4; while i > 0 { i = i - 1; task::spawn(|| test04_start() ); } - #debug("Finishing up."); + debug!{"Finishing up."}; } fn test05_start(ch: chan<int>) { @@ -113,15 +113,15 @@ fn test05() { } fn test06_start(&&task_number: int) { - #debug("Started task."); + debug!{"Started task."}; let mut i: int = 0; while i < 1000000 { i = i + 1; } - #debug("Finished task."); + debug!{"Finished task."}; } fn test06() { let number_of_tasks: int = 4; - #debug("Creating tasks"); + debug!{"Creating tasks"}; let mut i: int = 0; diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs index fff8cd4dba9..4349b75afc3 100644 --- a/src/test/run-pass/task-killjoin-rsrc.rs +++ b/src/test/run-pass/task-killjoin-rsrc.rs @@ -10,11 +10,11 @@ class notify { let ch: comm::chan<bool>; let v: @mut bool; new(ch: comm::chan<bool>, v: @mut bool) { self.ch = ch; self.v = v; } drop { - #error["notify: task=%? v=%x unwinding=%b b=%b", + error!{"notify: task=%? v=%x unwinding=%b b=%b", task::get_task(), ptr::addr_of(*(self.v)) as uint, task::failing(), - *(self.v)]; + *(self.v)}; let b = *(self.v); comm::send(self.ch, b); } @@ -23,9 +23,9 @@ class notify { fn joinable(+f: fn~()) -> comm::port<bool> { fn wrapper(+c: comm::chan<bool>, +f: fn()) { let b = @mut false; - #error["wrapper: task=%? allocated v=%x", + error!{"wrapper: task=%? allocated v=%x", task::get_task(), - ptr::addr_of(*b) as uint]; + ptr::addr_of(*b) as uint}; let _r = notify(c, b); f(); *b = true; @@ -44,13 +44,13 @@ fn supervised() { // Yield to make sure the supervisor joins before we // fail. This is currently not needed because the supervisor // runs first, but I can imagine that changing. - #error["supervised task=%?", task::get_task]; + error!{"supervised task=%?", task::get_task}; task::yield(); fail; } fn supervisor() { - #error["supervisor task=%?", task::get_task()]; + error!{"supervisor task=%?", task::get_task()}; let t = joinable(supervised); join(t); } diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index d30420aa26e..928eb301281 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -6,7 +6,7 @@ import task; fn main() { let mut i = 10; while i > 0 { task::spawn(|copy i| child(i) ); i = i - 1; } - #debug("main thread exiting"); + debug!{"main thread exiting"}; } fn child(&&x: int) { log(debug, x); } diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs index a25155db3d7..a821940ee76 100644 --- a/src/test/run-pass/unique-copy-box.rs +++ b/src/test/run-pass/unique-copy-box.rs @@ -7,6 +7,6 @@ fn main() unsafe { let rc1 = refcount(*i); let j = i; let rc2 = refcount(*i); - #error("rc1: %u rc2: %u", rc1, rc2); + error!{"rc1: %u rc2: %u", rc1, rc2}; assert rc1 + 1u == rc2; } \ No newline at end of file diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index cddf8824508..ac5f0d07f0a 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -6,11 +6,11 @@ import comm; class complainer { let c: comm::chan<bool>; new(c: comm::chan<bool>) { - #error("Hello!"); + error!{"Hello!"}; self.c = c; } - drop { #error("About to send!"); + drop { error!{"About to send!"}; comm::send(self.c, true); - #error("Sent!"); } + error!{"Sent!"}; } } fn f(c: comm::chan<bool>) { @@ -22,6 +22,6 @@ fn main() { let p = comm::port(); let c = comm::chan(p); task::spawn_unlinked(|| f(c) ); - #error("hiiiiiiiii"); + error!{"hiiiiiiiii"}; assert comm::recv(p); } diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index 104bea41e56..0b0f20a8b31 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -62,7 +62,7 @@ fn angrydome() { loop { i += 1; if i == 1 { alt check again { 1 { } } } break; } } -fn evil_lincoln() { let evil <- #debug("lincoln"); } +fn evil_lincoln() { let evil <- debug!{"lincoln"}; } fn main() { strange(); diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs index 8150dc7968f..5c57f91f6bf 100644 --- a/src/test/run-pass/while-with-break.rs +++ b/src/test/run-pass/while-with-break.rs @@ -11,7 +11,7 @@ fn main() { let v: ~[int] = ~[1, 2, 3, 4, 5]; // we check that it is freed by break - #debug("breaking"); + debug!{"breaking"}; break; } } diff --git a/src/test/run-pass/while.rs b/src/test/run-pass/while.rs index 4fce93acd35..62983346465 100644 --- a/src/test/run-pass/while.rs +++ b/src/test/run-pass/while.rs @@ -3,9 +3,9 @@ fn main() { let mut x: int = 10; let mut y: int = 0; - while y < x { log(debug, y); #debug("hello"); y = y + 1; } + while y < x { log(debug, y); debug!{"hello"}; y = y + 1; } while x > 0 { - #debug("goodbye"); + debug!{"goodbye"}; x = x - 1; log(debug, x); } diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs index 3f100da5fbc..4d880c4390e 100644 --- a/src/test/run-pass/yield.rs +++ b/src/test/run-pass/yield.rs @@ -6,14 +6,14 @@ import task::*; fn main() { let mut result = none; task::task().future_result(|-r| { result = some(r); }).spawn(child); - #error("1"); + error!{"1"}; yield(); - #error("2"); + error!{"2"}; yield(); - #error("3"); + error!{"3"}; future::get(option::unwrap(result)); } fn child() { - #error("4"); yield(); #error("5"); yield(); #error("6"); + error!{"4"}; yield(); error!{"5"}; yield(); error!{"6"}; } diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs index d22697b5ff8..51f837f74c5 100644 --- a/src/test/run-pass/yield1.rs +++ b/src/test/run-pass/yield1.rs @@ -6,9 +6,9 @@ import task::*; fn main() { let mut result = none; task::task().future_result(|-r| { result = some(r); }).spawn(child); - #error("1"); + error!{"1"}; yield(); future::get(option::unwrap(result)); } -fn child() { #error("2"); } +fn child() { error!{"2"}; } |