Register new snapshots, purge log_err and log_full in favour of log(...).

diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 3c56cdd9f611c7fb1210b96f0ae64196eb08e777..f3eaacb2ba3bf397a15b5bdf923ecc68877f7729 100644 (file)
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -269,11 +269,11 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         ref: ref,
         tags: tags
     });
-    log_full(core::debug, "  Loaded package: " + src.name + "/" + name);
+    log(debug, "  Loaded package: " + src.name + "/" + name);
 }
 
 fn load_source_packages(&c: cargo, &src: source) {
-    log_full(core::debug, "Loading source: " + src.name);
+    log(debug, "Loading source: " + src.name);
     let dir = fs::connect(c.sourcedir, src.name);
     let pkgfile = fs::connect(dir, "packages.json");
     if !fs::path_exists(pkgfile) { ret; }

diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index e7359fb2cdf9a6cc55e4148fdf13c9d9c9206cf4..98917342c2d68a57c9f748a744a501f5e10c0693 100644 (file)
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -596,7 +596,7 @@ fn rmext(filename: str) -> str {
         fs::connect(fs::dirname(out_filename), long_libname)
     } else { out_filename };
 
-    log_full(core::debug, "output: " + output);
+    log(debug, "output: " + output);
 
     // The default library location, we need this to find the runtime.
     // The location of crates will be determined as needed.

diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 56a38ec14b4919d0ee1062f6836cb5ff39984923..b19b33c79db794e1cec4fc8f72a02d42b46f06a3 100644 (file)
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -211,7 +211,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
               'a' { kind_noncopyable }
               c {
                 #error("unexpected char in encoded type param: ");
-                log_full(core::error, c);
+                log(error, c);
                 fail
               }
             };

diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs
index 1ad7d743b63ea3d1cf971c0585facad129c6cf50..b97b9a65510f0173fbda453154c068b58b3f2937 100644 (file)
--- a/src/comp/middle/debuginfo.rs
+++ b/src/comp/middle/debuginfo.rs
@@ -715,8 +715,8 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
     let dbg_cx = option::get(cx.dbg_cx);
 
     #debug("~~");
-    log_full(core::debug, fcx.id);
-    log_full(core::debug, cx.sess.span_str(fcx.sp));
+    log(debug, fcx.id);
+    log(debug, cx.sess.span_str(fcx.sp));
 
     let (ident, ret_ty, id) = alt cx.ast_map.get(fcx.id) {
       ast_map::node_item(item) {
@@ -746,8 +746,8 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
       }
     };
 
-    log_full(core::debug, ident);
-    log_full(core::debug, id);
+    log(debug, ident);
+    log(debug, id);
 
     let path = str::connect(fcx.lcx.path + [ident], "::");
 

diff --git a/src/comp/middle/fn_usage.rs b/src/comp/middle/fn_usage.rs
index 71fabffe9bce3cc233281f234c3c92dfc06af244..51858e2b8b7bf312e770df8f9fb7ac2e9f5c39c8 100644 (file)
--- a/src/comp/middle/fn_usage.rs
+++ b/src/comp/middle/fn_usage.rs
@@ -20,7 +20,7 @@ fn fn_usage_expr(expr: @ast::expr,
             alt ctx.tcx.def_map.find(expr.id) {
               some(ast::def_fn(_, ast::unsafe_fn.)) |
               some(ast::def_native_fn(_, ast::unsafe_fn.)) {
-                log_full(core::error, ("expr=", expr_to_str(expr)));
+                log(error, ("expr=", expr_to_str(expr)));
                 ctx.tcx.sess.span_fatal(
                     expr.span,
                     "unsafe functions can only be called");

diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 2b6fe006a2abfd18d030e3c09028bc4f49781777..393c7000bce6703d8cbc1a7ebab507133eaffb23 100644 (file)
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -447,9 +447,9 @@ fn visit_fn_block_with_scope(_e: @env, decl: fn_decl, blk: ast::blk,
                              span: span, id: node_id,
                              sc: scopes, v: vt<scopes>) {
     let scope = scope_fn_expr(decl, id, []);
-    log_full(core::debug, ("scope=", scope));
+    log(debug, ("scope=", scope));
     visit::visit_fn_block(decl, blk, span, id, cons(scope, @sc), v);
-    log_full(core::debug, ("unscope"));
+    log(debug, ("unscope"));
 }
 
 fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {

diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 2cd126be54d0df84a23ff66b577bb57dfd01d5fd..5df9f3fed8b5813eec5f4959f9607f2d6dcb5deb 100644 (file)
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -1120,7 +1120,7 @@ fn set_glue_inlining(cx: @local_ctxt, f: ValueRef, t: ty::t) {
 fn declare_tydesc(cx: @local_ctxt, sp: span, t: ty::t, ty_params: [uint],
                   is_obj_body: bool) ->
    @tydesc_info {
-    log_full(core::debug, "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t));
+    log(debug, "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t));
     let ccx = cx.ccx;
     let llsize;
     let llalign;
@@ -1156,7 +1156,7 @@ fn declare_tydesc(cx: @local_ctxt, sp: span, t: ty::t, ty_params: [uint],
           mutable cmp_glue: none::<ValueRef>,
           ty_params: ty_params,
           is_obj_body: is_obj_body};
-    log_full(core::debug, "--- declare_tydesc " + ty_to_str(cx.ccx.tcx, t));
+    log(debug, "--- declare_tydesc " + ty_to_str(cx.ccx.tcx, t));
     ret info;
 }
 

diff --git a/src/comp/middle/trans_build.rs b/src/comp/middle/trans_build.rs
index 021917f3d3e49c8b1e4ec44a955bb93c3123099a..40c13d64b4a74ab505f155cef5338a8ad1cf250e 100644 (file)
--- a/src/comp/middle/trans_build.rs
+++ b/src/comp/middle/trans_build.rs
@@ -516,7 +516,7 @@ fn add_span_comment(bcx: @block_ctxt, sp: span, text: str) {
     let ccx = bcx_ccx(bcx);
     if (!ccx.sess.get_opts().no_asm_comments) {
         let s = text + " (" + ccx.sess.span_str(sp) + ")";
-        log_full(core::debug, s);
+        log(debug, s);
         add_comment(bcx, s);
     }
 }

diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs
index 2cf7549da490df9b4b0bd170762d927c9e7385e6..65988ef917e4f304c537da166504a73aaa749299 100644 (file)
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -15,12 +15,12 @@
 fn collect_ids_stmt(s: @stmt, rs: @mutable [node_id]) {
     alt s.node {
       stmt_decl(_, id) {
-        log_full(core::debug, "node_id " + int::str(id));
+        log(debug, "node_id " + int::str(id));
         log_stmt(*s);;
         *rs += [id];
       }
       stmt_expr(_, id) {
-        log_full(core::debug, "node_id " + int::str(id));
+        log(debug, "node_id " + int::str(id));
         log_stmt(*s);;
         *rs += [id];
       }
@@ -44,7 +44,7 @@ fn node_ids_in_fn(body: blk, rs: @mutable [node_id]) {
 
 fn init_vecs(ccx: crate_ctxt, node_ids: [node_id], len: uint) {
     for i: node_id in node_ids {
-        log_full(core::debug, int::str(i) + " |-> " + uint::str(len));
+        log(debug, int::str(i) + " |-> " + uint::str(len));
         add_node(ccx, i, empty_ann(len));
     }
 }

diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index 2269469648a2521991a6f8cdff40e878b044ba56..baba4faa463ac42045564b914e909f5ee682eb9b 100644 (file)
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -78,7 +78,7 @@ fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> str {
 }
 
 fn log_tritv(fcx: fn_ctxt, v: tritv::t) {
-    log_full(core::debug, tritv_to_str(fcx, v));
+    log(debug, tritv_to_str(fcx, v));
 }
 
 fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t)
@@ -94,7 +94,7 @@ fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t)
 }
 
 fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) {
-    log_full(core::error, tritv_to_str(fcx, v));
+    log(error, tritv_to_str(fcx, v));
 }
 
 fn tos(v: [uint]) -> str {
@@ -107,9 +107,9 @@ fn tos(v: [uint]) -> str {
     ret rslt;
 }
 
-fn log_cond(v: [uint]) { log_full(core::debug, tos(v)); }
+fn log_cond(v: [uint]) { log(debug, tos(v)); }
 
-fn log_cond_err(v: [uint]) { log_full(core::error, tos(v)); }
+fn log_cond_err(v: [uint]) { log(error, tos(v)); }
 
 fn log_pp(pp: pre_and_post) {
     let p1 = tritv::to_vec(pp.precondition);
@@ -147,11 +147,11 @@ fn log_states_err(pp: pre_and_post_state) {
     log_cond_err(p2);
 }
 
-fn print_ident(i: ident) { log_full(core::debug, " " + i + " "); }
+fn print_ident(i: ident) { log(debug, " " + i + " "); }
 
 fn print_idents(&idents: [ident]) {
     if vec::len::<ident>(idents) == 0u { ret; }
-    log_full(core::debug, "an ident: " + vec::pop::<ident>(idents));
+    log(debug, "an ident: " + vec::pop::<ident>(idents));
     print_idents(idents);
 }
 
@@ -550,7 +550,7 @@ fn match_args(fcx: fn_ctxt, occs: @mutable [pred_args],
     #debug("match_args: looking at %s",
            constr_args_to_str(fn (i: inst) -> str { ret i.ident; }, occ));
     for pd: pred_args in *occs {
-        log_full(core::debug,
+        log(debug,
                  "match_args: candidate " + pred_args_to_str(pd));
         fn eq(p: inst, q: inst) -> bool { ret p.node == q.node; }
         if ty::args_eq(eq, pd.node.args, occ) { ret pd.node.bit_num; }
@@ -765,7 +765,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_<inst>] {
     for (constr_arg_general_<tup(ident, def_id)> p in rslt) {
         alt (p) {
             case (carg_ident(?p)) {
-                log_full(core::error, p._0);
+                log(error, p._0);
             }
             case (_) {}
         }
@@ -980,7 +980,7 @@ fn mentions<T>(&[T] s, &fn(&[T], def_id) -> bool q,
         alt (a.node) {
             case (carg_ident(?p1)) {
                 auto res = q(s, p1._1);
-                log_full(core::error, (res));
+                log(error, (res));
                 res
                     }
             case (_)               { false }

diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index ce6be98b124f15238e2c66db6531163a3125c21d..0b2f9a3e9a557311fab6d2008701e8274e7299c2 100644 (file)
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -72,7 +72,7 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) {
 
 
     #debug("check_states_stmt:");
-    log_full(core::debug, print::pprust::stmt_to_str(*s));
+    log(debug, print::pprust::stmt_to_str(*s));
     #debug("prec = ");
     log_tritv(fcx, prec);
     #debug("pres = ");

diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs
index c5756b7f9962040c49421f4ece004855d6c2ec31..b853643362b85e58894a43d8bc2ce24a4755aeb7 100644 (file)
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -13,7 +13,7 @@
 fn collect_local(loc: @local, cx: ctxt, v: visit::vt<ctxt>) {
     pat_bindings(loc.node.pat) {|p|
         let ident = alt p.node { pat_bind(id, _) { id } };
-        log_full(core::debug, "collect_local: pushing " + ident);;
+        log(debug, "collect_local: pushing " + ident);;
         *cx.cs += [respan(loc.span, ninit(p.id, ident))];
     };
     visit::visit_local(loc, cx, v);
@@ -65,7 +65,7 @@ fn find_locals(tcx: ty::ctxt,
 
 fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) ->
    uint {
-    log_full(core::debug,
+    log(debug,
              constraint_to_str(tcx, c) + " |-> " + uint::str(next));
     alt c.node {
       ninit(id, i) { tbl.insert(local_def(id), cinit(next, c.span, i)); }

diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index 6ac6daaa3fc45e863d70f6180811bf12f5dc5637..83acaaa590251fff05858e9fce5ab939def0291f 100644 (file)
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -276,7 +276,7 @@ fn handle_var(fcx: fn_ctxt, rslt: pre_and_post, id: node_id, name: ident) {
 }
 
 fn handle_var_def(fcx: fn_ctxt, rslt: pre_and_post, def: def, name: ident) {
-    log_full(core::debug, ("handle_var_def: ", def, name));
+    log(debug, ("handle_var_def: ", def, name));
     alt def {
       def_local(d_id, _) | def_arg(d_id, _) {
         use_var(fcx, d_id.node);
@@ -302,7 +302,7 @@ fn find_pre_post_expr_fn_upvars(fcx: fn_ctxt, e: @expr) {
     let rslt = expr_pp(fcx.ccx, e);
     clear_pp(rslt);
     for def in *freevars::get_freevars(fcx.ccx.tcx, e.id) {
-        log_full(core::debug, ("handle_var_def: def=", def));
+        log(debug, ("handle_var_def: def=", def));
         handle_var_def(fcx, rslt, def.def, "upvar");
     }
 }
@@ -358,7 +358,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
         vec::iter(cap_clause.moves, use_cap_item);
 
         vec::iter(cap_clause.moves) { |cap_item|
-            log_full(core::debug, ("forget_in_postcond: ", cap_item));
+            log(debug, ("forget_in_postcond: ", cap_item));
             forget_in_postcond(fcx, e.id, cap_item.id);
         }
       }

diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index e1f802954d11101ac7b580f619752fae3a779f5e..492570e9123faad1d936dbce56f5e85415059072 100644 (file)
--- a/src/comp/middle/tstate/states.rs
+++ b/src/comp/middle/tstate/states.rs
@@ -621,7 +621,7 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool {
     let stmt_ann = stmt_to_ann(fcx.ccx, *s);
 
     /*
-        log_full(core::error, ("[" + fcx.name + "]"));
+        log(error, ("[" + fcx.name + "]"));
         #error("*At beginning: stmt = ");
         log_stmt_err(*s);
         #error("*prestate = ");
@@ -653,7 +653,7 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool {
                             #error("poststate =");
                             log_tritv_err(fcx, stmt_ann.states.poststate);
                             #error("changed =");
-                            log_full(core::error, changed);
+                            log(error, changed);
             */
 
             ret changed;
@@ -727,7 +727,7 @@ fn find_pre_post_state_block(fcx: fn_ctxt, pres0: prestate, b: blk) -> bool {
         #error("post:");
         log_tritv_err(fcx, post);
         #error("changed = ");
-        log_full(core::error, changed);
+        log(error, changed);
     */
 
     ret changed;
@@ -774,7 +774,7 @@ fn find_pre_post_state_fn(fcx: fn_ctxt,
 
     /*
         #error("find_pre_post_state_fn");
-        log_full(core::error, changed);
+        log(error, changed);
         fcx.ccx.tcx.sess.span_note(f_body.span, fcx.name);
     */
 

diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index b91c19644bb16ba665f32770ec3989359cff8d00..0530b743eefdf143789158afbb70448789d674b4 100644 (file)
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -29,7 +29,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: @ast::expr,
                     "first argument to #fmt must be a " + "string literal.");
     let fmtspan = args[0].span;
     #debug("Format string:");
-    log_full(core::debug, fmt);
+    log(debug, fmt);
     fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: str) -> ! {
         cx.span_fatal(sp, msg);
     }
@@ -252,7 +252,7 @@ fn is_signed_type(cnv: conv) -> bool {
     }
     fn log_conv(c: conv) {
         alt c.param {
-          some(p) { log_full(core::debug, "param: " + int::to_str(p, 10u)); }
+          some(p) { log(debug, "param: " + int::to_str(p, 10u)); }
           _ { #debug("param: none"); }
         }
         for f: flag in c.flags {
@@ -265,20 +265,20 @@ fn log_conv(c: conv) {
             }
         }
         alt c.width {
-          count_is(i) { log_full(core::debug,
+          count_is(i) { log(debug,
                                  "width: count is " + int::to_str(i, 10u)); }
           count_is_param(i) {
-            log_full(core::debug,
+            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"); }
         }
         alt c.precision {
-          count_is(i) { log_full(core::debug,
+          count_is(i) { log(debug,
                                  "prec: count is " + int::to_str(i, 10u)); }
           count_is_param(i) {
-            log_full(core::debug,
+            log(debug,
                      "prec: count is param " + int::to_str(i, 10u));
           }
           count_is_next_param. { #debug("prec: count is next param"); }

diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 9821f7bdfa99dfa127e64581afc8f949a7acd398..338c29ddb071eb61d718107e8f1438544088272b 100644 (file)
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -580,7 +580,7 @@ fn read_line_comments(rdr: reader, code_to_the_left: bool) -> cmnt {
     let lines: [str] = [];
     while rdr.curr() == '/' && rdr.next() == '/' {
         let line = read_one_line_comment(rdr);
-        log_full(core::debug, line);
+        log(debug, line);
         lines += [line];
         consume_non_eol_whitespace(rdr);
     }
@@ -603,7 +603,7 @@ fn trim_whitespace_prefix_and_push_line(&lines: [str], s: str, col: uint) {
             s1 = str::slice(s, col, str::byte_len(s));
         } else { s1 = ""; }
     } else { s1 = s; }
-    log_full(core::debug, "pushing line: " + s1);
+    log(debug, "pushing line: " + s1);
     lines += [s1];
 }
 
@@ -707,7 +707,7 @@ fn gather_comments_and_literals(cm: codemap::codemap, path: str,
         if is_lit(tok.tok) {
             literals += [{lit: rdr.get_str_from(tok.bpos), pos: tok.chpos}];
         }
-        log_full(core::debug, "tok: " + token::to_str(rdr, tok.tok));
+        log(debug, "tok: " + token::to_str(rdr, tok.tok));
         first_read = false;
     }
     ret {cmnts: comments, lits: literals};

diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 209d56a51d031bc92ce5921591e594722b36c6a4..3f2c11dd821875ad0f9bbc39804bf1b62034df6f 100644 (file)
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -165,8 +165,7 @@ fn bad_expr_word_table() -> hashmap<str, ()> {
                  "cont", "ret", "be", "fail", "type", "resource", "check",
                  "assert", "claim", "native", "fn", "lambda", "pure",
                  "unsafe", "block", "import", "export", "let", "const",
-                 "log", "log_err", "log_full",
-                 "tag", "obj", "copy", "sendfn", "impl"] {
+                 "log", "tag", "obj", "copy", "sendfn", "impl"] {
         words.insert(word, ());
     }
     words
@@ -910,10 +909,7 @@ fn parse_expr_opt(p: parser) -> option::t<@ast::expr> {
             hi = e.span.hi;
             ex = ast::expr_fail(some(e));
         } else { ex = ast::expr_fail(none); }
-    } else if
-        (eat_word(p, "log_full")
-         || eat_word(p, "log")
-         || eat_word(p, "log_err")) {
+    } else if eat_word(p, "log") {
         expect(p, token::LPAREN);
         let lvl = parse_expr(p);
         expect(p, token::COMMA);

diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index e113817788b9a6daf8d3a9e372cf63944e392537..02e34ccee888e5a1a90e67f643a3417566641d19 100644 (file)
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -413,7 +413,7 @@ fn write_str(s: str) {
     fn print(x: token, L: int) {
         #debug("print %s %d (remaining line space=%d)", tok_str(x), L,
                space);
-        log_full(core::debug, buf_str(token, size, left, right, 6u));
+        log(debug, buf_str(token, size, left, right, 6u));
         alt x {
           BEGIN(b) {
             if L > space {

diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 976fa3f1b9663581e544285f19ec29bd0f9a3609..ac032ffa76a234344d999c80884f720d48522ad7 100644 (file)
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -916,7 +916,7 @@ fn print_opt(s: ps, expr: option::t<@ast::expr>) {
           1 { word_nbsp(s, "log"); print_expr(s, expr); }
           0 { word_nbsp(s, "log_err"); print_expr(s, expr); }
           2 {
-            word_nbsp(s, "log_full");
+            word_nbsp(s, "log");
             popen(s);
             print_expr(s, lexp);
             word(s.s, ",");

diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index 0a1bcc8a9f1084f10821c6ac248365ac799239e2..03a6136656a09c99b3f3a0349bda8adf512e156d 100644 (file)
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -36,38 +36,38 @@ fn field_exprs(fields: [ast::field]) -> [@ast::expr] {
 }
 
 fn log_expr(e: ast::expr) {
-    log_full(core::debug, print::pprust::expr_to_str(@e));
+    log(debug, print::pprust::expr_to_str(@e));
 }
 
 fn log_expr_err(e: ast::expr) {
-    log_full(core::error, print::pprust::expr_to_str(@e));
+    log(error, print::pprust::expr_to_str(@e));
 }
 
 fn log_ty_err(t: @ty) {
-    log_full(core::error, print::pprust::ty_to_str(t));
+    log(error, print::pprust::ty_to_str(t));
 }
 
 fn log_pat_err(p: @pat) {
-    log_full(core::error, print::pprust::pat_to_str(p));
+    log(error, print::pprust::pat_to_str(p));
 }
 
 fn log_block(b: ast::blk) {
-    log_full(core::debug, print::pprust::block_to_str(b));
+    log(debug, print::pprust::block_to_str(b));
 }
 
 fn log_block_err(b: ast::blk) {
-    log_full(core::error, print::pprust::block_to_str(b));
+    log(error, print::pprust::block_to_str(b));
 }
 
 fn log_item_err(i: @ast::item) {
-    log_full(core::error, print::pprust::item_to_str(i));
+    log(error, print::pprust::item_to_str(i));
 }
 fn log_stmt(st: ast::stmt) {
-    log_full(core::debug, print::pprust::stmt_to_str(st));
+    log(debug, print::pprust::stmt_to_str(st));
 }
 
 fn log_stmt_err(st: ast::stmt) {
-    log_full(core::error, print::pprust::stmt_to_str(st));
+    log(error, print::pprust::stmt_to_str(st));
 }
 
 fn has_nonlocal_exits(b: ast::blk) -> bool {

diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs
index 651bef071098d5f650695948de2bb9c51c85463a..6ffe1bda6b83499b0a1edc1629e992ff4c0f9d85 100644 (file)
--- a/src/compiletest/util.rs
+++ b/src/compiletest/util.rs
@@ -33,6 +33,6 @@ fn path_div() -> str { ":" }
 fn path_div() -> str { ";" }
 
 fn logv(config: config, s: str) {
-    log_full(core::debug, s);
+    log(debug, s);
     if config.verbose { io::stdout().write_line(s); }
 }

diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 4b37dede936bab3fdce4606dff5aa118c2df0806..91cb090b83cd8b31d0510ee808762fd3b898bb50 100644 (file)
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -242,9 +242,9 @@ fn check_variants_T<copy T>(
 
     if L < 100u {
         under(float::min(L, 20u)) {|i|
-            log_full(core::error, "Replacing... #" + uint::str(i));
+            log(error, "Replacing... #" + uint::str(i));
             under(float::min(L, 30u)) {|j|
-                log_full(core::error, "With... " + stringifier(@things[j]));
+                log(error, "With... " + stringifier(@things[j]));
                 let crate2 = @replacer(crate, i, things[j], cx.mode);
                 // It would be best to test the *crate* for stability, but testing the
                 // string for stability is easier and ok for now.
@@ -298,8 +298,8 @@ fn check_whole_compiler(code: str, suggested_filename_prefix: str, allow_running
         removeDirIfExists(suggested_filename_prefix + ".dSYM");
       }
       failed(s) {
-        log_full(core::error, "check_whole_compiler failure: " + s);
-        log_full(core::error, "Saved as: " + filename);
+        log(error, "check_whole_compiler failure: " + s);
+        log(error, "Saved as: " + filename);
       }
     }
 }
@@ -320,7 +320,7 @@ fn check_running(exe_filename: str) -> happiness {
     let p = std::run::program_output("/Users/jruderman/scripts/timed_run_rust_program.py", [exe_filename]);
     let comb = p.out + "\n" + p.err;
     if str::byte_len(comb) > 1u {
-        log_full(core::error, "comb comb comb: " + comb);
+        log(error, "comb comb comb: " + comb);
     }
 
     if contains(comb, "Assertion failed: (0), function alloc, file ../src/rt/rust_obstack.cpp") {
@@ -369,7 +369,7 @@ fn check_compiling(filename: str) -> happiness {
         } else if contains(p.err, "cast<Ty>() argument of incompatible type!") {
             known_bug("https://github.com/graydon/rust/issues/973")
         } else {
-            log_full(core::error, "Stderr: " + p.err);
+            log(error, "Stderr: " + p.err);
             failed("Unfamiliar error message")
         }
     } else if p.status == 0 {
@@ -382,7 +382,7 @@ fn check_compiling(filename: str) -> happiness {
     } else if contains(p.out, "trans_rec expected a rec but found _|_") {
         known_bug("https://github.com/graydon/rust/issues/924")
     } else if contains(p.out, "Assertion") && contains(p.out, "failed") {
-        log_full(core::error, "Stdout: " + p.out);
+        log(error, "Stdout: " + p.out);
         failed("Looks like an llvm assertion failure")
 
     } else if contains(p.out, "internal compiler error fail called with unsupported type _|_") {
@@ -396,14 +396,14 @@ fn check_compiling(filename: str) -> happiness {
     } else if contains(p.out, "internal compiler error unimplemented") {
         known_bug("Something unimplemented")
     } else if contains(p.out, "internal compiler error") {
-        log_full(core::error, "Stdout: " + p.out);
+        log(error, "Stdout: " + p.out);
         failed("internal compiler error")
 
     } else if contains(p.out, "error:") {
         cleanly_rejected("rejected with span_error")
     } else {
-        log_full(core::error, p.status);
-        log_full(core::error, "!Stdout: " + p.out);
+        log(error, p.status);
+        log(error, "!Stdout: " + p.out);
         failed("What happened?")
     }
 }
@@ -543,7 +543,7 @@ fn check_variants(files: [str], cx: context) {
             cont;
         }
 
-        log_full(core::error, "check_variants: " + file);
+        log(error, "check_variants: " + file);
         let sess = @{cm: codemap::new_codemap(), mutable next_id: 0};
         let crate =
             parser::parse_crate_from_source_str(

diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs
index 84ea81f9fceb3b880bd0d24d1f332373394f8799..29ab66872ce57751204f089cc596b8eea997c60d 100644 (file)
--- a/src/fuzzer/ivec_fuzz.rs
+++ b/src/fuzzer/ivec_fuzz.rs
@@ -91,9 +91,9 @@ fn vec_to_str(v: [int]) -> str {
 }
 
 fn show_edits(a: [int], xs: [int]) {
-    log_full(core::error, "=== Edits of " + vec_to_str(a) + " ===");
+    log(error, "=== Edits of " + vec_to_str(a) + " ===");
     let b = vec_edits(a, xs);
-    ix(0u, 1u, len(b)) {|i| log_full(core::error, vec_to_str(b[i])); }
+    ix(0u, 1u, len(b)) {|i| log(error, vec_to_str(b[i])); }
 }
 
 fn demo_edits() {

diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs
index 1dc1df2a7a3c25d6d0ad40859ac726177373efdd..de5f9e66f28ec54fbbe367c16e4315fb85651665 100644 (file)
--- a/src/fuzzer/rand_util.rs
+++ b/src/fuzzer/rand_util.rs
@@ -69,13 +69,13 @@ fn main()
 {
     let r = rand::mk_rng();
 
-    log_full(core::error, under(r, 5u));
-    log_full(core::error, choice(r, [10, 20, 30]));
-    log_full(core::error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
+    log(error, under(r, 5u));
+    log(error, choice(r, [10, 20, 30]));
+    log(error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
 
     let a = [mutable 1, 2, 3];
     shuffle(r, a);
-    log_full(core::error, a);
+    log(error, a);
 
     let i = 0u;
     let v = [
@@ -86,8 +86,8 @@ fn main()
     let w = weighted_vec(v);
 
     while i < 1000u {
-        log_full(core::error, "Immed: " + weighted_choice(r, v));
-        log_full(core::error, "Fast: " + choice(r, w));
+        log(error, "Immed: " + weighted_choice(r, v));
+        log(error, "Fast: " + choice(r, w));
         i += 1u;
     }
 }

diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 3b31832a9b71d28afd5b3c2a2996f2cc14efb64d..6cb3ada6a8808fd6b10b460cb90e8375305a518c 100644 (file)
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -287,7 +287,7 @@ fn from_chars(chs: [char]) -> str {
 > let i = 0;
 > while i < len(s) {
 >   let {ch, next} = char_range_at(s, i);
->   log_full(core::debug, ch);
+>   log(debug, ch);
 >   i = next;
 > }
 

diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index 05f953861f7da04ae67774cc4947f827d5a80489..503a336f7cd49d1bfe1dd437354f3f03cb8d48fe 100644 (file)
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -22,7 +22,7 @@
 Example:
 
 > spawn("Hello, World", fn (&&msg: str) {
->   log_full(core::debug, msg);
+>   log(debug, msg);
 > });
 
 */

diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 9719b8578e3972cf52f07f8092d184e766272da1..deb31f59ba0dcbc703bc9a0c6c40ef433cfabca7 100644 (file)
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -292,7 +292,7 @@ fn write(v: [u8]) unsafe {
             let nout = os::libc::write(fd, vbuf, len);
             if nout < 0 {
                 #error("error dumping buffer");
-                log_full(core::error, sys::last_os_error());
+                log(error, sys::last_os_error());
                 fail;
             }
             count += nout as uint;
@@ -334,7 +334,7 @@ fn file_buf_writer(path: str,
                                            os::libc_constants::S_IWUSR)
                     });
     ret if fd < 0i32 {
-        log_full(core::error, sys::last_os_error());
+        log(error, sys::last_os_error());
         result::err("error opening " + path)
     } else {
         result::ok(fd_buf_writer(fd, option::some(@fd_res(fd))))

diff --git a/src/snapshots.txt b/src/snapshots.txt
index e532681c8db8bb1ad2b59f94df9672b4a526aafc..543b3f5109d6a5fa7c068845ab99ceb4f819563e 100644 (file)
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,10 @@
+S 2011-12-22 ccb5b6f
+  winnt-i386 35be60caa888246e9710bd34ccbbe8a322d3c6de
+  linux-i386 8f88a285fa86613e268503a310e32cb053c2e300
+  macos-i386 c4cdd0a41fedb6d58d2a503ee3000c51d7878679
+  linux-x86_64 9c78b05bf4fba7d42e1d41c92790d018f98336ef
+  macos-x86_64 40d3bce53fefcd07e4f35b926e89fac2213792c1
+
 S 2011-12-22 3b61064
   winnt-i386 800fdc0e15f6917ff4318812edac611ca0162b5e
   linux-i386 468d13787022414aeb7f8ca755a4559691728a49

diff --git a/src/test/bench/99bob-iter.rs b/src/test/bench/99bob-iter.rs
index aec0422f5bff155518a4baed65adfe0b4bb1e220..eaab9d6b7310616f708e56ac9c5dc20640085dbf 100644 (file)
--- a/src/test/bench/99bob-iter.rs
+++ b/src/test/bench/99bob-iter.rs
@@ -47,10 +47,10 @@ fn ninetynine(it: block(int)) {
 
 fn main() {
     ninetynine {|n|
-        log_full(core::debug, sub(b1(), n));
-        log_full(core::debug, sub(b2(), n - 1));
+        log(debug, sub(b1(), n));
+        log(debug, sub(b2(), n - 1));
         #debug("");
     };
-    log_full(core::debug, b7());
-    log_full(core::debug, b8());
+    log(debug, b7());
+    log(debug, b8());
 }

diff --git a/src/test/bench/99bob-simple.rs b/src/test/bench/99bob-simple.rs
index 51439a8bd97164b42f7586e56403c7b912aa9979..6d8a17cc93218a5b47c5eb39e11106965d30bc73 100644 (file)
--- a/src/test/bench/99bob-simple.rs
+++ b/src/test/bench/99bob-simple.rs
@@ -43,10 +43,10 @@ fn sub(t: str, n: int) -> str {
 fn main() {
     let n: int = 99;
     while n > 0 {
-        log_full(core::debug, sub(b1(), n));
-        log_full(core::debug, sub(b2(), n - 1));
+        log(debug, sub(b1(), n));
+        log(debug, sub(b2(), n - 1));
         #debug(""); n -= 1;
     }
-    log_full(core::debug, b7());
-    log_full(core::debug, sub(b8(), 99));
+    log(debug, b7());
+    log(debug, sub(b8(), 99));
 }

diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs
index 1e4283443b9ddfb5fdb6eff41558d3c795e2ccde..c833cc92f800c7a84c3e45a3632de4024d0cc3ab 100644 (file)
--- a/src/test/bench/shootout-fannkuchredux.rs
+++ b/src/test/bench/shootout-fannkuchredux.rs
@@ -43,7 +43,7 @@ fn fannkuch(n: int) -> int {
 
         let go = true;
         while go {
-            if r == n { log_full(core::debug, checksum); ret flips; }
+            if r == n { log(debug, checksum); ret flips; }
             let p0 = perm1[0];
             i = 0;
             while i < r { let j = i + 1; perm1[i] = perm1[j]; i = j; }

diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 97bec11f43fced234b4a86c99ad3516695d89dd4..a47c0548a271962b14cdf9330c3ff2e6fb14996b 100644 (file)
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -44,31 +44,31 @@ fn bisect(v: [aminoacids], lo: uint, hi: uint, target: u32) -> char {
 }
 
 fn make_random_fasta(id: str, desc: str, genelist: [aminoacids], n: int) {
-    log_full(core::debug, ">" + id + " " + desc);
+    log(debug, ">" + id + " " + desc);
     let rng = myrandom(std::rand::mk_rng().next());
     let op: str = "";
     uint::range(0u, n as uint) {|i|
         str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
         if str::byte_len(op) >= LINE_LENGTH() {
-            log_full(core::debug, op);
+            log(debug, op);
             op = "";
         }
     }
-    if str::byte_len(op) > 0u { log_full(core::debug, op); }
+    if str::byte_len(op) > 0u { log(debug, op); }
 }
 
 fn make_repeat_fasta(id: str, desc: str, s: str, n: int) {
-    log_full(core::debug, ">" + id + " " + desc);
+    log(debug, ">" + id + " " + desc);
     let op: str = "";
     let sl: uint = str::byte_len(s);
     uint::range(0u, n as uint) {|i|
         str::push_byte(op, s[i % sl]);
         if str::byte_len(op) >= LINE_LENGTH() {
-            log_full(core::debug, op);
+            log(debug, op);
             op = "";
         }
     }
-    if str::byte_len(op) > 0u { log_full(core::debug, op); }
+    if str::byte_len(op) > 0u { log(debug, op); }
 }
 
 fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; }

diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs
index b9624ecb9e6e5cea992b124916d9be1ca5539af0..afb1b4a9289917991def9008e9e5fa2db81a123d 100644 (file)
--- a/src/test/bench/shootout-fibo.rs
+++ b/src/test/bench/shootout-fibo.rs
@@ -14,6 +14,6 @@ fn fib(n: int) -> int {
 fn main() {
     assert (fib(8) == 21);
     assert (fib(15) == 610);
-    log_full(core::debug, fib(8));
-    log_full(core::debug, fib(15));
+    log(debug, fib(8));
+    log(debug, fib(15));
 }

diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 72c98a4c3be270b522d637411464e40e551359ef..136d1057d2038ccc784e1a792242c2b7e1b0e7ff 100644 (file)
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -20,11 +20,11 @@ fn main() {
 
 
     for n: int in inputs {
-        log_full(core::debug, NBodySystem::energy(bodies));
+        log(debug, NBodySystem::energy(bodies));
 
         let i: int = 0;
         while i < n { NBodySystem::advance(bodies, 0.01); i += 1; }
-        log_full(core::debug, NBodySystem::energy(bodies));
+        log(debug, NBodySystem::energy(bodies));
     }
 }
 

diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 5c008c49019089da4f6c8857b2f0655e6a13510f..3ba6a6f7e2e92f4d02ecf5329e65ee8f974e38d9 100644 (file)
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -87,7 +87,7 @@ fn stress(num_tasks: int) {
 fn main(argv: [str]) {
     if vec::len(argv) == 1u {
         assert (fib(8) == 21);
-        log_full(core::debug, fib(8));
+        log(debug, fib(8));
     } else {
         // Interactive mode! Wooo!!!!
         let opts = parse_opts(argv);

diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index dcab0e8bde548af10107814296833491c0d0d38e..cf8986aa0f7337509cd0f421c628127699573abd 100644 (file)
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -88,7 +88,7 @@ fn map_task<send K1, send K2,
                 send V>(-map: mapper<K1, K2, V>,
                           -ctrl: chan<ctrl_proto<K2, V>>,
                     -input: K1) {
-        // log_full(core::error, "map_task " + input);
+        // log(error, "map_task " + input);
         let intermediates = treemap::init();
 
         fn emit<send K2,
@@ -172,15 +172,15 @@ fn map_reduce<send K1, send K2,
               }
               find_reducer(k, cc) {
                 let c;
-                // log_full(core::error, "finding reducer for " + k);
+                // log(error, "finding reducer for " + k);
                 alt treemap::find(reducers, k) {
                   some(_c) {
-                    // log_full(core::error,
+                    // log(error,
                     // "reusing existing reducer for " + k);
                     c = _c;
                   }
                   none. {
-                    // log_full(core::error, "creating new reducer for " + k);
+                    // log(error, "creating new reducer for " + k);
                     let p = port();
                     let r = reduce, kk = k;
                     tasks +=
@@ -229,7 +229,7 @@ fn main(argv: [str]) {
     let elapsed = stop - start;
     elapsed /= 1000000u64;
 
-    log_full(core::error, "MapReduce completed in "
+    log(error, "MapReduce completed in "
              + u64::str(elapsed) + "ms");
 }
 

diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index a05ce493ddf5a740029a1ee0710866835e1b258e..26d40d9c731fabb3e91f40bd5b03e56730102662 100644 (file)
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -78,7 +78,7 @@ fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: [str]) ->
 
     fn map_task(args: (chan<ctrl_proto>, str)) {
         let (ctrl, input) = args;
-        // log_full(core::error, "map_task " + input);
+        // log(error, "map_task " + input);
         let intermediates = map::new_str_hash();
 
         fn emit(im: map::hashmap<str, chan<reduce_proto>>,
@@ -158,15 +158,15 @@ fn map_reduce(-inputs: [str]) {
               }
               find_reducer(k, cc) {
                 let c;
-                // log_full(core::error, "finding reducer for " + k);
+                // log(error, "finding reducer for " + k);
                 alt reducers.find(k) {
                   some(_c) {
-                    // log_full(core::error,
+                    // log(error,
                     // "reusing existing reducer for " + k);
                     c = _c;
                   }
                   none. {
-                    // log_full(core::error, "creating new reducer for " + k);
+                    // log(error, "creating new reducer for " + k);
                     let p = port();
                     tasks +=
                         [task::spawn_joinable((k, chan(p)), reduce_task)];
@@ -201,7 +201,7 @@ fn main(argv: [str]) {
     let elapsed = stop - start;
     elapsed /= 1000000u64;
 
-    log_full(core::error, "MapReduce completed in "
+    log(error, "MapReduce completed in "
              + u64::str(elapsed) + "ms");
 }
 

diff --git a/src/test/compile-fail/alt-join.rs b/src/test/compile-fail/alt-join.rs
index a950cc117e3a1858e7eb4d5ec9d01805cd08d4d9..0845b33eacfec99041467cab5b39ad0c67bfe19a 100644 (file)
--- a/src/test/compile-fail/alt-join.rs
+++ b/src/test/compile-fail/alt-join.rs
@@ -7,6 +7,6 @@
 fn main() {
     alt true { false { my_fail(); } true { } }
 
-    log_full(core::debug, x);
+    log(debug, x);
     let x: int;
 }

diff --git a/src/test/compile-fail/and-init.rs b/src/test/compile-fail/and-init.rs
index 6b966f4964d49f3336a5fd6d585d87fd1bdf8a50..b0b4c0da5e30f8d695463386503e0c5740520e30 100644 (file)
--- a/src/test/compile-fail/and-init.rs
+++ b/src/test/compile-fail/and-init.rs
@@ -3,6 +3,6 @@
 fn main() {
     let i: int;
 
-    log_full(core::debug, false && { i = 5; true });
-    log_full(core::debug, i);
+    log(debug, false && { i = 5; true });
+    log(debug, i);
 }

diff --git a/src/test/compile-fail/anon-obj-overriding-wrong-type.rs b/src/test/compile-fail/anon-obj-overriding-wrong-type.rs
index eeeae1793b7a3b55218b0ff912920c93f6364828..764cb7bdb41c80c2c8ee4790520339f3a59b483b 100644 (file)
--- a/src/test/compile-fail/anon-obj-overriding-wrong-type.rs
+++ b/src/test/compile-fail/anon-obj-overriding-wrong-type.rs
@@ -18,5 +18,5 @@ fn main() {
             my_a
         };
 
-    log_full(core::error, my_b.foo());
+    log(error, my_b.foo());
 }

diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs
index 16c83c56a9e48a9809cb0e21fd46120ced365f16..112066d1dea5c6167192bc6811ef4a34017dfc84 100644 (file)
--- a/src/test/compile-fail/autoderef-full-lval.rs
+++ b/src/test/compile-fail/autoderef-full-lval.rs
@@ -7,11 +7,11 @@ fn main() {
     let a: clam = {x: @1, y: @2};
     let b: clam = {x: @10, y: @20};
     let z: int = a.x + b.y;
-    log_full(core::debug, z);
+    log(debug, z);
     assert (z == 21);
     let forty: fish = {a: @40};
     let two: fish = {a: @2};
     let answer: int = forty.a + two.a;
-    log_full(core::debug, answer);
+    log(debug, answer);
     assert (answer == 42);
 }

diff --git a/src/test/compile-fail/bad-bang-ann-2.rs b/src/test/compile-fail/bad-bang-ann-2.rs
index 375eadac779d65a3ad9939f5a9bd7a442bc66d36..8fb6a9e873705df230ffdc1131a7b29862139e2f 100644 (file)
--- a/src/test/compile-fail/bad-bang-ann-2.rs
+++ b/src/test/compile-fail/bad-bang-ann-2.rs
@@ -2,6 +2,6 @@
 // Tests that a function with a ! annotation always actually fails
 // error-pattern: some control paths may return
 
-fn bad_bang(i: uint) -> ! { log_full(core::debug, 3); }
+fn bad_bang(i: uint) -> ! { log(debug, 3); }
 
 fn main() { bad_bang(5u); }

diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 0ef523e753d68ccea7760d6c3bbe3b4faffd9c0b..c849c17a9cbb2ffe632c72f097789cf2db0fb840 100644 (file)
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -1,4 +1,4 @@
 // error-pattern:expected str but found int
 
 const i: str = 10;
-fn main() { log_full(core::debug, i); }
+fn main() { log(debug, i); }

diff --git a/src/test/compile-fail/bad-env-capture.rs b/src/test/compile-fail/bad-env-capture.rs
index 340a38e4993a6ba2f745df3e7cba7417d97676a5..0246580db1a26ffd40f6e2a31aaa0fdaf329f6c2 100644 (file)
--- a/src/test/compile-fail/bad-env-capture.rs
+++ b/src/test/compile-fail/bad-env-capture.rs
@@ -1,6 +1,6 @@
 // error-pattern: attempted dynamic environment-capture
 fn foo() {
     let x: int;
-    fn bar() { log_full(core::debug, x); }
+    fn bar() { log(debug, x); }
 }
 fn main() { foo(); }

diff --git a/src/test/compile-fail/bad-env-capture2.rs b/src/test/compile-fail/bad-env-capture2.rs
index 420aaa280c2ec8fcb3e974ce157b8d91d55fc2b6..9c50d29fa4eb1ad04a29f39257c0fdd74dca2b66 100644 (file)
--- a/src/test/compile-fail/bad-env-capture2.rs
+++ b/src/test/compile-fail/bad-env-capture2.rs
@@ -1,5 +1,5 @@
 // error-pattern: attempted dynamic environment-capture
 fn foo(x: int) {
-    fn bar() { log_full(core::debug, x); }
+    fn bar() { log(debug, x); }
 }
 fn main() { foo(2); }

diff --git a/src/test/compile-fail/bad-env-capture3.rs b/src/test/compile-fail/bad-env-capture3.rs
index 4b2e2c74ffd26218e68521288980e946aae8d4e5..673a22ce11ab6f9477d7f85a3ca9a68193a765ce 100644 (file)
--- a/src/test/compile-fail/bad-env-capture3.rs
+++ b/src/test/compile-fail/bad-env-capture3.rs
@@ -1,7 +1,7 @@
 // error-pattern: attempted dynamic environment-capture
 obj foo(x: int) {
     fn mth() {
-        fn bar() { log_full(core::debug, x); }
+        fn bar() { log(debug, x); }
     }
 }
 

diff --git a/src/test/compile-fail/bad-expr-path.rs b/src/test/compile-fail/bad-expr-path.rs
index ad9e147deeb94a57af5421c40c64ecc88130e56e..d70d935f602a3177063ed2ce8f69221d2ed3c12d 100644 (file)
--- a/src/test/compile-fail/bad-expr-path.rs
+++ b/src/test/compile-fail/bad-expr-path.rs
@@ -2,4 +2,4 @@
 
 mod m1 { }
 
-fn main(args: [str]) { log_full(core::debug, m1::a); }
+fn main(args: [str]) { log(debug, m1::a); }

diff --git a/src/test/compile-fail/bad-expr-path2.rs b/src/test/compile-fail/bad-expr-path2.rs
index 273f93bac2237231a9c1242d4139000aa53fc5ca..da6cfb652b5c078f8b3390e677302e1d54d277d0 100644 (file)
--- a/src/test/compile-fail/bad-expr-path2.rs
+++ b/src/test/compile-fail/bad-expr-path2.rs
@@ -4,4 +4,4 @@ mod m1 {
     mod a { }
 }
 
-fn main(args: [str]) { log_full(core::debug, m1::a); }
+fn main(args: [str]) { log(debug, m1::a); }

diff --git a/src/test/compile-fail/block-coerce-no.rs b/src/test/compile-fail/block-coerce-no.rs
index 1a41ece08c03a39cabeb214e5d2ce93d2dbe37c0..2985d98a34aac4ee553b39c6fde992d9f2cd30a6 100644 (file)
--- a/src/test/compile-fail/block-coerce-no.rs
+++ b/src/test/compile-fail/block-coerce-no.rs
@@ -12,5 +12,5 @@ fn fn_id(f: fn()) -> fn() { ret f }
 
 fn main() {
     let i = 8;
-    let f = coerce(block () { log_full(core::error, i); });
+    let f = coerce(block () { log(error, i); });
     f(); }

diff --git a/src/test/compile-fail/block-copy.rs b/src/test/compile-fail/block-copy.rs
index 7afefb0f36f0ac646f7af718dfda29564f78989f..63a2e9bcb391cd5f603482742454a9cf958c9690 100644 (file)
--- a/src/test/compile-fail/block-copy.rs
+++ b/src/test/compile-fail/block-copy.rs
@@ -3,6 +3,6 @@
 fn lol(f: block()) -> block() { ret f; }
 fn main() {
     let i = 8;
-    let f = lol(block () { log_full(core::error, i); });
+    let f = lol(block () { log(error, i); });
     f();
 }

diff --git a/src/test/compile-fail/block-require-return.rs b/src/test/compile-fail/block-require-return.rs
index 1bff806ab46e15d19d61948631f2daad9f2b3673..dc14053084dd217560bab3820d515c61befbb884 100644 (file)
--- a/src/test/compile-fail/block-require-return.rs
+++ b/src/test/compile-fail/block-require-return.rs
@@ -1,3 +1,3 @@
 // error-pattern: not all control paths return
 fn force(f: block() -> int) -> int { f() }
-fn main() { log_full(core::error, force({|| })); }
+fn main() { log(error, force({|| })); }

diff --git a/src/test/compile-fail/block-uninit.rs b/src/test/compile-fail/block-uninit.rs
index 68870a1b876049a4fe879674b37dbc5e717b1006..4d7f73b341c79c9d3b4ca71d6d6757f87a6ccf75 100644 (file)
--- a/src/test/compile-fail/block-uninit.rs
+++ b/src/test/compile-fail/block-uninit.rs
@@ -1,4 +1,4 @@
 // error-pattern: Unsatisfied precondition constraint
 
 fn force(f: block()) { f(); }
-fn main() { let x: int; force(block () { log_full(core::error, x); }); }
+fn main() { let x: int; force(block () { log(error, x); }); }

diff --git a/src/test/compile-fail/break-uninit.rs b/src/test/compile-fail/break-uninit.rs
index a7a6a92fd7ca3ad7ce27d6bebbdf1e32ba8e9ca6..b5e8d2a909fdca73966c34eba2f8a13231f0a3bc 100644 (file)
--- a/src/test/compile-fail/break-uninit.rs
+++ b/src/test/compile-fail/break-uninit.rs
@@ -6,9 +6,9 @@ fn foo() -> int {
 
     do  { i = 0; break; x = 0; } while x != 0
 
-    log_full(core::debug, x);
+    log(debug, x);
 
     ret 17;
 }
 
-fn main() { log_full(core::debug, foo()); }
+fn main() { log(debug, foo()); }

diff --git a/src/test/compile-fail/break-uninit2.rs b/src/test/compile-fail/break-uninit2.rs
index 3547f56545121eb9c3fa9af1c32a6a29fc7cd9f6..262e536b44542cbc69f74f15335691234bbc1c8f 100644 (file)
--- a/src/test/compile-fail/break-uninit2.rs
+++ b/src/test/compile-fail/break-uninit2.rs
@@ -6,9 +6,9 @@ fn foo() -> int {
 
     do  { i = 0; break; x = 0; } while 1 != 2
 
-    log_full(core::debug, x);
+    log(debug, x);
 
     ret 17;
 }
 
-fn main() { log_full(core::debug, foo()); }
+fn main() { log(debug, foo()); }

diff --git a/src/test/compile-fail/constrained-type-missing-check.rs b/src/test/compile-fail/constrained-type-missing-check.rs
index 912a7f27dcc02294f0c6802545b666e814ad71c8..bed10a12de5644ba4c630957c0b0490a4235a43d 100644 (file)
--- a/src/test/compile-fail/constrained-type-missing-check.rs
+++ b/src/test/compile-fail/constrained-type-missing-check.rs
@@ -12,5 +12,5 @@ fn main() {
     let a: int = 1;
     let b: int = 2;
     let c: ordered_range = {low: a, high: b};
-    log_full(core::debug, c.low);
+    log(debug, c.low);
 }

diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs
index 546dbbd411d51410ee7fbba51b8e48dc5f7c6639..c37ccd29f0db33160b7036ded8bf63c178774d2d 100644 (file)
--- a/src/test/compile-fail/copy-a-resource.rs
+++ b/src/test/compile-fail/copy-a-resource.rs
@@ -2,4 +2,4 @@
 
 resource foo(i: int) { }
 
-fn main() { let x <- foo(10); let y = x; log_full(core::error, x); }
+fn main() { let x <- foo(10); let y = x; log(error, x); }

diff --git a/src/test/compile-fail/dead-code-be.rs b/src/test/compile-fail/dead-code-be.rs
index 68334f0fda046d31def46bc4fb8b93c0b8a2572a..bc7ec4491eeab10917847c24a16b37740201227a 100644 (file)
--- a/src/test/compile-fail/dead-code-be.rs
+++ b/src/test/compile-fail/dead-code-be.rs
@@ -3,7 +3,7 @@
 
 // error-pattern: dead
 
-fn f(caller: str) { log_full(core::debug, caller); }
+fn f(caller: str) { log(debug, caller); }
 
 fn main() { be f("main"); #debug("Paul is dead"); }
 

diff --git a/src/test/compile-fail/dead-code-ret.rs b/src/test/compile-fail/dead-code-ret.rs
index f7f530dc90ae12f6cb4e29f031d6c076160f3eca..3d9ec1dfad3db6fb23436be1b018e401e81df3ff 100644 (file)
--- a/src/test/compile-fail/dead-code-ret.rs
+++ b/src/test/compile-fail/dead-code-ret.rs
@@ -3,7 +3,7 @@
 
 // error-pattern: dead
 
-fn f(caller: str) { log_full(core::debug, caller); }
+fn f(caller: str) { log(debug, caller); }
 
 fn main() { ret f("main"); #debug("Paul is dead"); }
 

diff --git a/src/test/compile-fail/do-while-constraints.rs b/src/test/compile-fail/do-while-constraints.rs
index 479908a8d3ce469514f32670a1fb11f1f23b9a2b..20bd01fb2acf0a64354ccfa92bfc19848bf6b5ed 100644 (file)
--- a/src/test/compile-fail/do-while-constraints.rs
+++ b/src/test/compile-fail/do-while-constraints.rs
@@ -4,7 +4,7 @@ fn main() {
     let y: int = 42;
     let x: int;
     do  {
-        log_full(core::debug, y);
+        log(debug, y);
         do  { do  { do  { x <- y; } while true } while true } while true
     } while true
 }

diff --git a/src/test/compile-fail/do-while-pred-constraints.rs b/src/test/compile-fail/do-while-pred-constraints.rs
index 8bf0356439302a91a8719231d1267e50f77cef5d..b044d56944bb0238fa1bf58f9b676da9fb5b034e 100644 (file)
--- a/src/test/compile-fail/do-while-pred-constraints.rs
+++ b/src/test/compile-fail/do-while-pred-constraints.rs
@@ -1,6 +1,6 @@
 // error-pattern: Unsatisfied precondition constraint (for example, even(y
 
-fn print_even(y: int) : even(y) { log_full(core::debug, y); }
+fn print_even(y: int) : even(y) { log(debug, y); }
 
 pure fn even(y: int) -> bool { true }
 

diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs
index 13163fa32f246310b85e82b62a2b8891abca016c..bda344587d9eb9fa550434dc63f95b482c802be6 100644 (file)
--- a/src/test/compile-fail/export.rs
+++ b/src/test/compile-fail/export.rs
@@ -1,8 +1,8 @@
 // error-pattern: unresolved name
 mod foo {
     export x;
-    fn x(y: int) { log_full(core::debug, y); }
-    fn z(y: int) { log_full(core::debug, y); }
+    fn x(y: int) { log(debug, y); }
+    fn z(y: int) { log(debug, y); }
 }
 
 fn main() { foo::z(10); }

diff --git a/src/test/compile-fail/fn-constraint.rs b/src/test/compile-fail/fn-constraint.rs
index e5fac40b8fb17b041a1cedb4ecedaaae2986674e..aadbecc40a7c185600b19c7ab617d78c387a691c 100644 (file)
--- a/src/test/compile-fail/fn-constraint.rs
+++ b/src/test/compile-fail/fn-constraint.rs
@@ -5,5 +5,5 @@
 fn main() {
     let a: uint = 4u;
     let b: uint = 1u;
-    log_full(core::error, safe_slice("kitties", a, b));
+    log(error, safe_slice("kitties", a, b));
 }

diff --git a/src/test/compile-fail/fn-expr-type-state.rs b/src/test/compile-fail/fn-expr-type-state.rs
index 9c998682fc321808468545d71a9e14a20a7116a1..5eb7541a520339fa381351e80caecefefec5b75e 100644 (file)
--- a/src/test/compile-fail/fn-expr-type-state.rs
+++ b/src/test/compile-fail/fn-expr-type-state.rs
@@ -3,5 +3,5 @@
 fn main() {
     // Typestate should work even in a lambda. we should reject this program.
     let f = fn () -> int { let i: int; ret i; };
-    log_full(core::error, f());
+    log(error, f());
 }

diff --git a/src/test/compile-fail/fn-expr-typestate-2.rs b/src/test/compile-fail/fn-expr-typestate-2.rs
index 5f2e6db0e8bbe1c4a1ac8b2b3e4ae3483c9f51ab..8e35bc341b1a10bbdf565ebd415aad6dcae2a372 100644 (file)
--- a/src/test/compile-fail/fn-expr-typestate-2.rs
+++ b/src/test/compile-fail/fn-expr-typestate-2.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let j = fn () -> int { let i: int; ret i; }();
-    log_full(core::error, j);
+    log(error, j);
 }

diff --git a/src/test/compile-fail/if-check-precond-fail.rs b/src/test/compile-fail/if-check-precond-fail.rs
index 69dedb579551642b18036cd6545baaf24b6da129..cd6ebeb126b2a463e3fc726627d1c3986bc6b8b5 100644 (file)
--- a/src/test/compile-fail/if-check-precond-fail.rs
+++ b/src/test/compile-fail/if-check-precond-fail.rs
@@ -5,7 +5,7 @@
     } else if x == 2u { ret true; } else { ret even(x - 2u); }
 }
 
-fn print_even(x: uint) : even(x) { log_full(core::debug, x); }
+fn print_even(x: uint) : even(x) { log(debug, x); }
 
 fn foo(x: uint) { if check even(x) { fail; } else { print_even(x); } }
 

diff --git a/src/test/compile-fail/if-without-else-result.rs b/src/test/compile-fail/if-without-else-result.rs
index 6c560ffb41d36cdb867d5f0c362b6d6218ecc53d..0ff469a871c080c488f41f15523f9698b73514cb 100644 (file)
--- a/src/test/compile-fail/if-without-else-result.rs
+++ b/src/test/compile-fail/if-without-else-result.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let a = if true { true };
-    log_full(core::debug, a);
+    log(debug, a);
 }
\ No newline at end of file

diff --git a/src/test/compile-fail/lambda-mutate-nested.rs b/src/test/compile-fail/lambda-mutate-nested.rs
index 8b5da1c196ab5c4698c6ad89b7909fa5adbf67b3..0a733687aa3373b17030a4940a0f2b6a9fde4486 100644 (file)
--- a/src/test/compile-fail/lambda-mutate-nested.rs
+++ b/src/test/compile-fail/lambda-mutate-nested.rs
@@ -6,10 +6,10 @@
 fn main() {
     let i = 0;
     let ctr = lambda () -> int { f2({|| i = i + 1; }); ret i; };
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, i);
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, i);
 }

diff --git a/src/test/compile-fail/lambda-mutate.rs b/src/test/compile-fail/lambda-mutate.rs
index c5b90f9edde229a4b80dfb6ecfd597c97d69e5b1..6ba1cfc5401e9b25913f9b4bf998722f2778e647 100644 (file)
--- a/src/test/compile-fail/lambda-mutate.rs
+++ b/src/test/compile-fail/lambda-mutate.rs
@@ -3,10 +3,10 @@
 fn main() {
     let i = 0;
     let ctr = lambda () -> int { i = i + 1; ret i; };
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, ctr());
-    log_full(core::error, i);
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, ctr());
+    log(error, i);
 }

diff --git a/src/test/compile-fail/move-arg.rs b/src/test/compile-fail/move-arg.rs
index fd5566e5c32aa43a3b2e6f3fc9f1842b176996cc..711e9a7095c16e55fbea6e36232c3b7838706763 100644 (file)
--- a/src/test/compile-fail/move-arg.rs
+++ b/src/test/compile-fail/move-arg.rs
@@ -1,4 +1,4 @@
 // error-pattern: Unsatisfied precondition constraint
 fn test(-foo: int) { assert (foo == 10); }
 
-fn main() { let x = 10; test(x); log_full(core::debug, x); }
+fn main() { let x = 10; test(x); log(debug, x); }

diff --git a/src/test/compile-fail/no-constraint-prop.rs b/src/test/compile-fail/no-constraint-prop.rs
index 8cae7c2fc36440157d6c460e437282c470cea4d7..2a03395f1c161a96fa0496bcc98825b0f007caef 100644 (file)
--- a/src/test/compile-fail/no-constraint-prop.rs
+++ b/src/test/compile-fail/no-constraint-prop.rs
@@ -16,5 +16,5 @@ fn main() {
     // the next statement, since it's not true in the
     // prestate.
     let d <- a;
-    log_full(core::debug, safe_slice("kitties", b, d));
+    log(debug, safe_slice("kitties", b, d));
 }

diff --git a/src/test/compile-fail/nonscalar-cast.rs b/src/test/compile-fail/nonscalar-cast.rs
index 95de145e52e94d2ac72f457d9e5570fea840d6ef..4347044d2a334616b57c0ad541546d934e8ac3b8 100644 (file)
--- a/src/test/compile-fail/nonscalar-cast.rs
+++ b/src/test/compile-fail/nonscalar-cast.rs
@@ -4,5 +4,5 @@
 import std::os;
 
 fn main() {
-  log_full(core::debug, { x: 1 } as int);
+  log(debug, { x: 1 } as int);
 }

diff --git a/src/test/compile-fail/nonsense-constraints.rs b/src/test/compile-fail/nonsense-constraints.rs
index 527644907f0170e2569c835707dcc7ddcbe615af..08b261a2ccd9644ff5d1c1757ca6799ce580bf02 100644 (file)
--- a/src/test/compile-fail/nonsense-constraints.rs
+++ b/src/test/compile-fail/nonsense-constraints.rs
@@ -10,4 +10,4 @@ fn enum_chars(start: u8, end: u8) : uint::le(start, end) -> [char] {
     ret r;
 }
 
-fn main() { log_full(core::debug, enum_chars('a' as u8, 'z' as u8)); }
+fn main() { log(debug, enum_chars('a' as u8, 'z' as u8)); }

diff --git a/src/test/compile-fail/or-init.rs b/src/test/compile-fail/or-init.rs
index 54ab6c3c1b7c7f01a5fb37dcf320fd8cf0dfcb7b..778a9d8cb7bc3b29862b742dfc6bfe2a4abcfbf3 100644 (file)
--- a/src/test/compile-fail/or-init.rs
+++ b/src/test/compile-fail/or-init.rs
@@ -3,6 +3,6 @@
 fn main() {
     let i: int;
 
-    log_full(core::debug, false || { i = 5; true });
-    log_full(core::debug, i);
+    log(debug, false || { i = 5; true });
+    log(debug, i);
 }

diff --git a/src/test/compile-fail/oversized-literal.rs b/src/test/compile-fail/oversized-literal.rs
index c189c97ded978c079076d5db7a085eba5a4c310e..005a29cc435c21aab1679d4a15cdc3a72fb4bf8d 100644 (file)
--- a/src/test/compile-fail/oversized-literal.rs
+++ b/src/test/compile-fail/oversized-literal.rs
@@ -1,3 +1,3 @@
 // error-pattern:literal out of range
 
-fn main() { log_full(core::debug, 300u8); }
+fn main() { log(debug, 300u8); }

diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index 3484a14f0840ac4c5616e941ae056b3161bc7d99..8190b74efc76cc7f46747682857a751e52a540fd 100644 (file)
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -10,7 +10,7 @@
 fn foo(t: bar) {
     alt t {
       t1(_, some::<int>(x)) {
-        log_full(core::debug, x);
+        log(debug, x);
       }
       _ { fail; }
     }

diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs
index a7c7d06cb5fb4a29013dde9b2874f3870d6e8990..9244b4b73b3f34bbdf54c92312496ea949f506ad 100644 (file)
--- a/src/test/compile-fail/pinned-deep-copy.rs
+++ b/src/test/compile-fail/pinned-deep-copy.rs
@@ -10,7 +10,7 @@ fn main() {
         // Can't do this copy
         let x = ~~~{y: r(i)};
         let z = x;
-        log_full(core::debug, x);
+        log(debug, x);
     }
-    log_full(core::error, *i);
+    log(error, *i);
 }
\ No newline at end of file

diff --git a/src/test/compile-fail/rec-missing-fields.rs b/src/test/compile-fail/rec-missing-fields.rs
index 523641698d31576f82b2a841bad79dea3f950192..fad12e24a7cdd5800c2ee742ae30ca71e90a6c96 100644 (file)
--- a/src/test/compile-fail/rec-missing-fields.rs
+++ b/src/test/compile-fail/rec-missing-fields.rs
@@ -6,4 +6,4 @@
 
 type point = {x: int, y: int};
 
-fn main() { let p: point = {x: 10}; log_full(core::debug, p.y); }
+fn main() { let p: point = {x: 10}; log(debug, p.y); }

diff --git a/src/test/compile-fail/record-with-resource.rs b/src/test/compile-fail/record-with-resource.rs
index ff6a197abf839293c99f2e50696917db471d6d41..6cdaafb22a5747bb76a40993322c0be64c3204aa 100644 (file)
--- a/src/test/compile-fail/record-with-resource.rs
+++ b/src/test/compile-fail/record-with-resource.rs
@@ -1,13 +1,13 @@
 // error-pattern: copying a noncopyable value
 
 resource my_resource(x: int) {
-    log_full(core::error, x);
+    log(error, x);
 }
 
 fn main() {
     {
         let a = {x: 0, y: my_resource(20)};
         let b = {x: 2 with a};
-        log_full(core::error, (a, b));
+        log(error, (a, b));
     }
 }

diff --git a/src/test/compile-fail/reference-in-loop.rs b/src/test/compile-fail/reference-in-loop.rs
index a21523d0763394756ea3b53771ec0e7a621f89c7..403e0bb07cb78134ab561b7ee03f1160957c8848 100644 (file)
--- a/src/test/compile-fail/reference-in-loop.rs
+++ b/src/test/compile-fail/reference-in-loop.rs
@@ -4,7 +4,7 @@ fn main() {
     let x = [];
     let &y = x;
     while true {
-        log_full(core::error, y);
+        log(error, y);
         x = [1];
     }
 }

diff --git a/src/test/compile-fail/sendfn-is-not-a-lambda.rs b/src/test/compile-fail/sendfn-is-not-a-lambda.rs
index 4cc76c93a17b6cad12bf15a5131d4ce36ced9ef0..3456a4f6a1af5f1e4167cd0a52bb05caa726d3c9 100644 (file)
--- a/src/test/compile-fail/sendfn-is-not-a-lambda.rs
+++ b/src/test/compile-fail/sendfn-is-not-a-lambda.rs
@@ -6,5 +6,5 @@ fn test(f: lambda(uint) -> uint) -> uint {
 
 fn main() {
     let f = sendfn(x: uint) -> uint { ret 4u; };
-    log_full(core::debug, test(f));
+    log(debug, test(f));
 }
\ No newline at end of file

diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs
index 4cf50b119f8090b3e0ef2e7ee9076dace47f89e9..97e4515d98d3657ea20e138380713cb12959165a 100644 (file)
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -6,5 +6,5 @@
 fn main() {
     let i <- ~r(true);
     let j = i;
-    log_full(core::debug, i);
+    log(debug, i);
 }
\ No newline at end of file

diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index 9fa456aaacb0a8c19a1d8f35dbd6f4061e3931b7..fdc9072fd930e7c159a7ad10c2130498927a90d8 100644 (file)
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -14,6 +14,6 @@ fn main() {
     let r1 <- [~r(i1)];
     let r2 <- [~r(i2)];
     f(r1, r2);
-    log_full(core::debug, (r2, *i1));
-    log_full(core::debug, (r1, *i2));
+    log(debug, (r2, *i1));
+    log(debug, (r1, *i2));
 }
\ No newline at end of file

diff --git a/src/test/compile-fail/unsafe-alias-2.rs b/src/test/compile-fail/unsafe-alias-2.rs
index 94b95e190bd6f24deb116425b6812746fac42477..ec1e5c01ffb7b4c506fde3abe6067ae72fabefd2 100644 (file)
--- a/src/test/compile-fail/unsafe-alias-2.rs
+++ b/src/test/compile-fail/unsafe-alias-2.rs
@@ -4,5 +4,5 @@
 
 fn main() {
     let box = @mutable {mutable x: 1};
-    alt *box { x { whoknows(box); log_full(core::error, x); } }
+    alt *box { x { whoknows(box); log(error, x); } }
 }

diff --git a/src/test/compile-fail/unsafe-alias.rs b/src/test/compile-fail/unsafe-alias.rs
index 2b71a5e72d893a6e6629e69a740292baf8925ab0..905a6a922f16a0e6a1cd1d5eae9c81147330ca58 100644 (file)
--- a/src/test/compile-fail/unsafe-alias.rs
+++ b/src/test/compile-fail/unsafe-alias.rs
@@ -1,6 +1,6 @@
 // error-pattern:may alias with argument
 
-fn foo(x: {mutable x: int}, f: fn@()) { log_full(core::debug, x); }
+fn foo(x: {mutable x: int}, f: fn@()) { log(debug, x); }
 
 fn whoknows(x: @mutable {mutable x: int}) { *x = {mutable x: 10}; }
 

diff --git a/src/test/compile-fail/unsafe-alt.rs b/src/test/compile-fail/unsafe-alt.rs
index e19edcfddc7ec04aa610639fca4a9d745c54ba1c..56adb4411ba698d45ad4588970524dbbda3d22b1 100644 (file)
--- a/src/test/compile-fail/unsafe-alt.rs
+++ b/src/test/compile-fail/unsafe-alt.rs
@@ -4,5 +4,5 @@
 
 fn main() {
     let x = left({mutable x: 10});
-    alt x { left(i) { x = right(false); log_full(core::debug, i); } _ { } }
+    alt x { left(i) { x = right(false); log(debug, i); } _ { } }
 }

diff --git a/src/test/compile-fail/unsafe-for.rs b/src/test/compile-fail/unsafe-for.rs
index caaab6d89773f0e1462f1b33d9aa7e9ace4d284b..05bad8ee833da30d0095545cfd341f9ee09871e5 100644 (file)
--- a/src/test/compile-fail/unsafe-for.rs
+++ b/src/test/compile-fail/unsafe-for.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let v: [mutable {mutable x: int}] = [mutable {mutable x: 1}];
-    for x in v { v[0] = {mutable x: 2}; log_full(core::debug, x); }
+    for x in v { v[0] = {mutable x: 2}; log(debug, x); }
 }

diff --git a/src/test/compile-fail/unsafe-mutable-alias.rs b/src/test/compile-fail/unsafe-mutable-alias.rs
index f740d7d7592bb05d5218b1daea6805a2508ce457..3ab7fe974a534cb2f704ffba8d60930cf74fbf51 100644 (file)
--- a/src/test/compile-fail/unsafe-mutable-alias.rs
+++ b/src/test/compile-fail/unsafe-mutable-alias.rs
@@ -5,4 +5,4 @@ fn f(a: {mutable x: int}, &b: {mutable x: int}) -> int {
     ret a.x + b.x;
 }
 
-fn main() { let i = {mutable x: 4}; log_full(core::debug, f(i, i)); }
+fn main() { let i = {mutable x: 4}; log(debug, f(i, i)); }

diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs
index 26decd8baebf023ecacabedb4d9d0828884819a3..6beb247e931225c10aaf2691bd52c6212218efbc 100644 (file)
--- a/src/test/compile-fail/unsupported-cast.rs
+++ b/src/test/compile-fail/unsupported-cast.rs
@@ -4,5 +4,5 @@
 import std::os;
 
 fn main() {
-  log_full(core::debug, 1.0 as os::libc::FILE); // Can't cast float to native.
+  log(debug, 1.0 as os::libc::FILE); // Can't cast float to native.
 }

diff --git a/src/test/compile-fail/use-after-move.rs b/src/test/compile-fail/use-after-move.rs
index e0a06d73acc8d78a635ae804e4c410de4be0dcc2..d4d42b555381904a4074d2dd0b4258b745b082a6 100644 (file)
--- a/src/test/compile-fail/use-after-move.rs
+++ b/src/test/compile-fail/use-after-move.rs
@@ -1,2 +1,2 @@
 // error-pattern: Unsatisfied precondition constraint (for example, init(x
-fn main() { let x = @5; let y <- x; log_full(core::debug, *x); }
+fn main() { let x = @5; let y <- x; log(debug, *x); }

diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs
index dfd34aa1168bd8159fe38d440df2a81a19fd0c37..7dc3f7b4a329b5ebdeeab980c0916c2b2bd029bb 100644 (file)
--- a/src/test/compile-fail/use-after-send.rs
+++ b/src/test/compile-fail/use-after-send.rs
@@ -1,16 +1,16 @@
 // error-pattern: Unsatisfied precondition constraint
 fn send<send T>(ch: _chan<T>, -data: T) {
-    log_full(core::debug, ch);
-    log_full(core::debug, data);
+    log(debug, ch);
+    log(debug, data);
     fail;
 }
 type _chan<T> = int;
 
-// Tests that "log_full(core::debug, message);" is flagged as using
+// Tests that "log(debug, message);" is flagged as using
 // message after the send deinitializes it
 fn test00_start(ch: _chan<int>, message: int, count: int) {
     send(ch, message);
-    log_full(core::debug, message);
+    log(debug, message);
 }
 
 fn main() { fail; }

diff --git a/src/test/compile-fail/use-uninit-2.rs b/src/test/compile-fail/use-uninit-2.rs
index abbca6008fccd4bffbf6e2c9cf9bebd394e58967..be9494536993e75c0a41b829fda98bd9a7624116 100644 (file)
--- a/src/test/compile-fail/use-uninit-2.rs
+++ b/src/test/compile-fail/use-uninit-2.rs
@@ -1,5 +1,5 @@
 // error-pattern:Unsatisfied precondition
 
-fn foo(x: int) { log_full(core::debug, x); }
+fn foo(x: int) { log(debug, x); }
 
 fn main() { let x: int; if 1 > 2 { x = 10; } foo(x); }

diff --git a/src/test/compile-fail/use-uninit-3.rs b/src/test/compile-fail/use-uninit-3.rs
index e731ba4f083f5a1b74d1df826f0b645d8e69bb14..b824567133a0020a9fb56f02d6296dc20ae017e1 100644 (file)
--- a/src/test/compile-fail/use-uninit-3.rs
+++ b/src/test/compile-fail/use-uninit-3.rs
@@ -1,6 +1,6 @@
 // error-pattern:Unsatisfied precondition
 
-fn foo(x: int) { log_full(core::debug, x); }
+fn foo(x: int) { log(debug, x); }
 
 fn main() {
     let x: int;

diff --git a/src/test/compile-fail/use-uninit.rs b/src/test/compile-fail/use-uninit.rs
index 5fac7d3ee6b49cb681678f6f68a96e3edad07c76..5c3c9a3cda763ae6eae0d4b19b1ec554f8fc2b80 100644 (file)
--- a/src/test/compile-fail/use-uninit.rs
+++ b/src/test/compile-fail/use-uninit.rs
@@ -1,5 +1,5 @@
 // error-pattern:Unsatisfied precondition
 
-fn foo(x: int) { log_full(core::debug, x); }
+fn foo(x: int) { log(debug, x); }
 
 fn main() { let x: int; foo(x); }

diff --git a/src/test/compile-fail/vec-field.rs b/src/test/compile-fail/vec-field.rs
index c376441163dc918e621a36e35613081f885f1833..df697c8af67bcd777ecb38fe537d4b8b2e62db5e 100644 (file)
--- a/src/test/compile-fail/vec-field.rs
+++ b/src/test/compile-fail/vec-field.rs
@@ -3,7 +3,7 @@
 
 fn f() {
     let v = [1];
-    log_full(core::debug, v.some_field_name); //type error
+    log(debug, v.some_field_name); //type error
 }
 
 fn main() { }

diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs
index d2fb07bd1f71e833504c1f9b9ce936cc24bd9798..ce1aae2fa8a238677fece0d3f12243436ed09dc4 100644 (file)
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -7,5 +7,5 @@ fn main() {
     let i <- [r(0)];
     let j <- [r(1)];
     let k = i + j;
-    log_full(core::debug, j);
+    log(debug, j);
 }

diff --git a/src/test/compile-fail/while-loop-constraints.rs b/src/test/compile-fail/while-loop-constraints.rs
index 15cb4ab9902db33513381afa7775354fa5bd0f8a..287ee2d684cc579957c09ad3c08cf167ee390dcb 100644 (file)
--- a/src/test/compile-fail/while-loop-constraints.rs
+++ b/src/test/compile-fail/while-loop-constraints.rs
@@ -4,7 +4,7 @@ fn main() {
     let y: int = 42;
     let x: int;
     while true {
-        log_full(core::debug, y);
+        log(debug, y);
         while true {
             while true {
                 while true { x <- y; }

diff --git a/src/test/compile-fail/while-loop-pred-constraints.rs b/src/test/compile-fail/while-loop-pred-constraints.rs
index 6ea21de7f58703953daa2a1a76a9db59c8319f6a..aa31a3857dce0190f79fe84dc19e8a7fce78d51f 100644 (file)
--- a/src/test/compile-fail/while-loop-pred-constraints.rs
+++ b/src/test/compile-fail/while-loop-pred-constraints.rs
@@ -1,6 +1,6 @@
 // error-pattern: Unsatisfied precondition constraint (for example, even(y
 
-fn print_even(y: int) : even(y) { log_full(core::debug, y); }
+fn print_even(y: int) : even(y) { log(debug, y); }
 
 pure fn even(y: int) -> bool { true }
 

diff --git a/src/test/run-fail/binop-fail-2.rs b/src/test/run-fail/binop-fail-2.rs
index 2203adbd7a73f817884be88c1eec1315c57898b5..adef5da4d0e6d8cd81a89d2cac925c976f3080df 100644 (file)
--- a/src/test/run-fail/binop-fail-2.rs
+++ b/src/test/run-fail/binop-fail-2.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; }
+fn my_err(s: str) -> ! { log(error, s); fail "quux"; }
 fn main() { 3u == my_err("bye"); }

diff --git a/src/test/run-fail/binop-fail.rs b/src/test/run-fail/binop-fail.rs
index d8aefe7d6df11dbb4a3af81fcea85a3aa0af8eb6..83368cd1a07ceaf8bbefcf9cccc8570e6d773099 100644 (file)
--- a/src/test/run-fail/binop-fail.rs
+++ b/src/test/run-fail/binop-fail.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; }
+fn my_err(s: str) -> ! { log(error, s); fail "quux"; }
 fn main() { my_err("bye") == 3u; }

diff --git a/src/test/run-fail/fail-arg.rs b/src/test/run-fail/fail-arg.rs
index bdb8ecc9453468eafff4f267af2d82604b0b303f..a5d14f143039ce045fd1d76e517bb9dd5bd2b40e 100644 (file)
--- a/src/test/run-fail/fail-arg.rs
+++ b/src/test/run-fail/fail-arg.rs
@@ -1,4 +1,4 @@
 // error-pattern:woe
-fn f(a: int) { log_full(core::debug, a); }
+fn f(a: int) { log(debug, a); }
 
 fn main() { f(fail "woe"); }

diff --git a/src/test/run-fail/fn-constraint.rs b/src/test/run-fail/fn-constraint.rs
index 6f466ea1f64e940354493c62d74ba0de50d3cd8f..40e259a0446a030b5aa18b6d7874e315b908d546 100644 (file)
--- a/src/test/run-fail/fn-constraint.rs
+++ b/src/test/run-fail/fn-constraint.rs
@@ -7,5 +7,5 @@ fn main() {
     let a: uint = 4u;
     let b: uint = 1u;
     check (le(a, b));
-    log_full(core::error, safe_slice("kitties", a, b));
+    log(error, safe_slice("kitties", a, b));
 }

diff --git a/src/test/run-fail/if-check-fail.rs b/src/test/run-fail/if-check-fail.rs
index 0bf23e4a93c9961a7ca0f73d56a3c0d7e19874f2..31e95d5c385dfc56fce74b02c82eb319854bda23 100644 (file)
--- a/src/test/run-fail/if-check-fail.rs
+++ b/src/test/run-fail/if-check-fail.rs
@@ -7,7 +7,7 @@
 
 fn foo(x: uint) {
     if check even(x) {
-        log_full(core::debug, x);
+        log(debug, x);
     } else {
         fail "Number is odd";
     }

diff --git a/src/test/run-fail/if-cond-bot.rs b/src/test/run-fail/if-cond-bot.rs
index a9877ab4b7a29126c82f226a8c3827618dd01d74..71b7323240dbaf1082d73c1813cf65e6af666247 100644 (file)
--- a/src/test/run-fail/if-cond-bot.rs
+++ b/src/test/run-fail/if-cond-bot.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; }
+fn my_err(s: str) -> ! { log(error, s); fail "quux"; }
 fn main() { if my_err("bye") { } }

diff --git a/src/test/run-pass/alt-bot.rs b/src/test/run-pass/alt-bot.rs
index 314483ca5345fd62e0f4fa11f696d8d2f9967380..ca9e0482519213d70113dd70111505b2b4389529 100644 (file)
--- a/src/test/run-pass/alt-bot.rs
+++ b/src/test/run-pass/alt-bot.rs
@@ -2,5 +2,5 @@
 fn main() {
     let i: int =
         alt some::<int>(3) { none::<int>. { fail } some::<int>(_) { 5 } };
-    log_full(core::debug, i);
+    log(debug, i);
 }

diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index 8d8a6517a7dfdc7db1eeb11ea7f1125a5f3ca288..d6af174757cecd67101b700098ffbd05fbd1b3a9 100644 (file)
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -13,12 +13,12 @@ fn foo(s: @int) {
 
     alt x {
       make_t(y) {
-        log_full(core::debug, y); // ref up then down
+        log(debug, y); // ref up then down
 
       }
       _ { #debug("?"); fail; }
     }
-    log_full(core::debug, dbg::refcount(s));
+    log(debug, dbg::refcount(s));
     assert (dbg::refcount(s) == count + 1u);
 }
 
@@ -27,6 +27,6 @@ fn main() {
 
     foo(s); // ref up then down
 
-    log_full(core::debug, dbg::refcount(s));
+    log(debug, dbg::refcount(s));
     assert (dbg::refcount(s) == 1u);
 }

diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs
index f25c78b03e4583b6ffc3d5a582124c8e7dba9a4a..462e6acda4e047422df386c1df01b182f0a01a23 100644 (file)
--- a/src/test/run-pass/alt-tag.rs
+++ b/src/test/run-pass/alt-tag.rs
@@ -11,9 +11,9 @@
 fn process(c: color) -> int {
     let x: int;
     alt c {
-      rgb(r, _, _) { #debug("rgb"); log_full(core::debug, r); x = r; }
-      rgba(_, _, _, a) { #debug("rgba"); log_full(core::debug, a); x = a; }
-      hsl(_, s, _) { #debug("hsl"); log_full(core::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/argv.rs b/src/test/run-pass/argv.rs
index c4b544c7c68995fab4087d167079b9d5e3d3a326..7ed3bc4505d888a316e57b6bce5c2dba6c4e5dab 100644 (file)
--- a/src/test/run-pass/argv.rs
+++ b/src/test/run-pass/argv.rs
@@ -1,5 +1,5 @@
 fn main(args: [str]) {
     let vs: [str] = ["hi", "there", "this", "is", "a", "vec"];
     let vvs: [[str]] = [args, vs];
-    for vs: [str] in vvs { for s: str in vs { log_full(core::debug, s); } }
+    for vs: [str] in vvs { for s: str in vs { log(debug, s); } }
 }

diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs
index 1649900305a552a74b6ba88114cc263fd1289a2a..d86349346bd4b00718ac85ea2b8aab3020ad3162 100644 (file)
--- a/src/test/run-pass/arith-0.rs
+++ b/src/test/run-pass/arith-0.rs
@@ -2,6 +2,6 @@
 
 fn main() {
     let a: int = 10;
-    log_full(core::debug, a);
+    log(debug, a);
     assert (a * (a - 1) == 90);
 }

diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs
index d1c6ac117a37082365635e5553defce790f5cec2..f815c2e4801d377371e84ed643b6013f2a6e5331 100644 (file)
--- a/src/test/run-pass/arith-1.rs
+++ b/src/test/run-pass/arith-1.rs
@@ -18,6 +18,6 @@ fn main() {
     assert (i32_b << 1 == i32_b << 1);
     assert (i32_b >> 1 == i32_b >> 1);
     assert (i32_b & i32_b << 1 == 0);
-    log_full(core::debug, i32_b | i32_b << 1);
+    log(debug, i32_b | i32_b << 1);
     assert (i32_b | i32_b << 1 == 0x30303030);
 }

diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index 5c963b6cc51e210c0318ea07161f37cd4a9842f3..ed8c71aecbadee88e82caa2427882ac351c79442 100644 (file)
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -5,6 +5,6 @@
 fn f<copy T, copy U>(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; }
 
 fn main() {
-    log_full(core::debug, f({x: 3, y: 4, z: 5}, 4).a.x);
-    log_full(core::debug, f(5, 6).a);
+    log(debug, f({x: 3, y: 4, z: 5}, 4).a.x);
+    log(debug, f(5, 6).a);
 }

diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index 6affd11366e9e332aa95cf4d8cd79796f73353d4..efeb8b88b156cf5c3d14bf6f11fa64017975ee03 100644 (file)
--- a/src/test/run-pass/basic.rs
+++ b/src/test/run-pass/basic.rs
@@ -21,8 +21,8 @@ fn a(c: chan<int>) {
 fn k(x: int) -> int { ret 15; }
 
 fn g(x: int, y: str) -> int {
-    log_full(core::debug, x);
-    log_full(core::debug, y);
+    log(debug, x);
+    log(debug, y);
     let z: int = k(1);
     ret z;
 }
@@ -35,7 +35,7 @@ fn main() {
     task::spawn(chan(p), b);
     let x: int = 10;
     x = g(n, s);
-    log_full(core::debug, x);
+    log(debug, x);
     n = recv(p);
     n = recv(p);
     // FIXME: use signal-channel for this.

diff --git a/src/test/run-pass/bind-generic.rs b/src/test/run-pass/bind-generic.rs
index 6a0c1ea46330deb5a0b584caae7663b61d41fd03..e12caefe1401c41fa695f72a65d3b8a409600d3c 100644 (file)
--- a/src/test/run-pass/bind-generic.rs
+++ b/src/test/run-pass/bind-generic.rs
@@ -1,6 +1,6 @@
 fn wrapper3<copy T>(i: T, j: int) {
-    log_full(core::debug, i);
-    log_full(core::debug, j);
+    log(debug, i);
+    log(debug, j);
     // This is a regression test that the spawn3 thunk to wrapper3
     // correctly finds the value of j
     assert j == 123456789;

diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs
index cbf936429a3b8a90c4196d7693fb0c32ddd057c3..9c2ff78248caca90d6db357ef596d1165ac66270 100644 (file)
--- a/src/test/run-pass/bitwise.rs
+++ b/src/test/run-pass/bitwise.rs
@@ -18,8 +18,8 @@ fn general() {
     a ^= b;
     b ^= a;
     a = a ^ b;
-    log_full(core::debug, a);
-    log_full(core::debug, b);
+    log(debug, a);
+    log(debug, b);
     assert (b == 1);
     assert (a == 2);
     assert (!0xf0 & 0xff == 0xf);

diff --git a/src/test/run-pass/block-explicit-types.rs b/src/test/run-pass/block-explicit-types.rs
index 71bd75d03b6b300abecf21bc24f49eeef729426d..85bb68e7387bd2c0448a70402d72f6b545412eca 100644 (file)
--- a/src/test/run-pass/block-explicit-types.rs
+++ b/src/test/run-pass/block-explicit-types.rs
@@ -1,4 +1,4 @@
 fn main() {
     fn as_buf<T>(s: str, f: block(str) -> T) -> T { f(s) }
-    as_buf("foo", {|foo: str| -> () log_full(core::error, foo);});
+    as_buf("foo", {|foo: str| -> () log(error, foo);});
 }

diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index 2a2f754ca8631a4106b8d526d12df615527b3589..0f09aae2409b6064855c91101c5574c994566aa1 100644 (file)
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -4,12 +4,12 @@ fn main() {
     let v = [1, 2, 3, 4, 5, 6, 7];
     let odds = 0;
     iter_vec(v, {|i|
-        log_full(core::error, i);
+        log(error, i);
         if i % 2 == 1 {
             odds += 1;
         }
-        log_full(core::error, odds);
+        log(error, odds);
     });
-    log_full(core::error, odds);
+    log(error, odds);
     assert (odds == 4);
 }

diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index d5d3d45160f07b5dc4b4c3432d98014af34937e7..bec21791c9055130dc66a8684b2bb3bbfa93631b 100644 (file)
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -5,10 +5,10 @@ fn main() {
     let sum = 0;
     iter_vec(v, {|i|
         iter_vec(v, {|j|
-            log_full(core::error, i * j);
+            log(error, i * j);
             sum += i * j;
         });
     });
-    log_full(core::error, sum);
+    log(error, sum);
     assert (sum == 225);
 }

diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 7569d78b42d0470fcb4e08982f49914dd91a86ce..0532f0133836fe08036008851eb1d3cef37fb615 100644 (file)
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -6,6 +6,6 @@ fn main() {
         vec::map2([1, 2, 3, 4, 5],
                   [true, false, false, true, true],
                   {|i, b| if b { -i } else { i } });
-    log_full(core::error, v);
+    log(error, v);
     assert (v == [-1, 2, 3, -4, -5]);
 }

diff --git a/src/test/run-pass/bug-862.rs b/src/test/run-pass/bug-862.rs
index 4b6193f312c18c7ecf2b1bfadfb54ddecccd8f41..8172cae6b47e070db09a3b0092b4df396b1294b2 100644 (file)
--- a/src/test/run-pass/bug-862.rs
+++ b/src/test/run-pass/bug-862.rs
@@ -4,4 +4,4 @@ fn f(i: int, j: int) : p(j) -> int { j }
 
 fn g(i: int, j: int) : p(j) -> int { f(i, j) }
 
-fn main() { let x = 1; check (p(x)); log_full(core::debug, g(x, x)); }
+fn main() { let x = 1; check (p(x)); log(debug, g(x, x)); }

diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index 13ae1bbb7f6dd844a3186084afe31a8b7c8064f2..14b21a242bddd890f3054f4ebbefdcba7c7bc819 100644 (file)
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -12,7 +12,7 @@ fn main() {
     let t = task::spawn(chan(p), child);
     let y = recv(p);
     #error("received");
-    log_full(core::error, y);
+    log(error, y);
     assert (y == 10);
 }
 

diff --git a/src/test/run-pass/command-line-args.rs b/src/test/run-pass/command-line-args.rs
index 19251a2b97ea2ee67d33cb265bf935ee6aafb18f..02ba8f16996da283c42c818b5ec175e1d1ae920b 100644 (file)
--- a/src/test/run-pass/command-line-args.rs
+++ b/src/test/run-pass/command-line-args.rs
@@ -1,3 +1,3 @@
 
 
-fn main(args: [str]) { log_full(core::debug, args[0]); }
+fn main(args: [str]) { log(debug, args[0]); }

diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs
index 4345170818ef96939e8a1a25727dcf9722496d49..854711286ddb50a30e8778ba3cf5e219fdfe176a 100644 (file)
--- a/src/test/run-pass/complex.rs
+++ b/src/test/run-pass/complex.rs
@@ -27,7 +27,7 @@ fn foo(x: int) -> int {
 
 fn main() {
     let x: int = 2 + 2;
-    log_full(core::debug, x);
+    log(debug, x);
     #debug("hello, world");
-    log_full(core::debug, 10);
+    log(debug, 10);
 }

diff --git a/src/test/run-pass/const.rs b/src/test/run-pass/const.rs
index bfc75cf68d7ef10bb3a4fa7a19f5569b9c8a2464..6f33b369620cfd9e18b38bfb6c95d3a5c8c2638f 100644 (file)
--- a/src/test/run-pass/const.rs
+++ b/src/test/run-pass/const.rs
@@ -2,4 +2,4 @@
 
 const i: int = 10;
 
-fn main() { log_full(core::debug, i); }
+fn main() { log(debug, i); }

diff --git a/src/test/run-pass/constraint-prop-expr-move.rs b/src/test/run-pass/constraint-prop-expr-move.rs
index 001268e5fd6e26116319cb84a411d21c72f201d5..7848d9b9bd5392f9c9c826d3f1f640835b4b34e0 100644 (file)
--- a/src/test/run-pass/constraint-prop-expr-move.rs
+++ b/src/test/run-pass/constraint-prop-expr-move.rs
@@ -8,5 +8,5 @@ fn main() {
     let c: uint = 17u;
     check (le(a, b));
     c <- a;
-    log_full(core::debug, safe_slice("kitties", c, b));
+    log(debug, safe_slice("kitties", c, b));
 }

diff --git a/src/test/run-pass/constraint-prop-move.rs b/src/test/run-pass/constraint-prop-move.rs
index 52d3a3551279736f895612c8f5581c9e710fd1d8..347ea13f0051d5c93863af6033513949ce53e16e 100644 (file)
--- a/src/test/run-pass/constraint-prop-move.rs
+++ b/src/test/run-pass/constraint-prop-move.rs
@@ -7,5 +7,5 @@ fn main() {
     let b: uint = 4u;
     check (le(a, b));
     let c <- a;
-    log_full(core::debug, safe_slice("kitties", c, b));
+    log(debug, safe_slice("kitties", c, b));
 }

diff --git a/src/test/run-pass/constraint-prop-swap.rs b/src/test/run-pass/constraint-prop-swap.rs
index 16dd8b8fbe2a5759f43821c0f27e04211a20641a..748044893ed5f53928c7f5c9e2412a16bc3548fb 100644 (file)
--- a/src/test/run-pass/constraint-prop-swap.rs
+++ b/src/test/run-pass/constraint-prop-swap.rs
@@ -7,5 +7,5 @@ fn main() {
     let b: uint = 1u;
     check (le(b, a));
     b <-> a;
-    log_full(core::debug, safe_slice("kitties", a, b));
+    log(debug, safe_slice("kitties", a, b));
 }

diff --git a/src/test/run-pass/constraint-prop.rs b/src/test/run-pass/constraint-prop.rs
index 089047d6eeda95713bfbcbb61e98f7254011050a..f15c0f4121d77000c6dfa1f2c39c6edd61f63efd 100644 (file)
--- a/src/test/run-pass/constraint-prop.rs
+++ b/src/test/run-pass/constraint-prop.rs
@@ -7,5 +7,5 @@ fn main() {
     let b: uint = 4u;
     check (le(a, b));
     let c = b;
-    log_full(core::debug, safe_slice("kitties", a, c));
+    log(debug, safe_slice("kitties", a, c));
 }

diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs
index 0f494131ab83e6b844582213c096ab9f2d92f5b9..2784b16b99a2e1230271fadede8df8294a2dac99 100644 (file)
--- a/src/test/run-pass/deref-lval.rs
+++ b/src/test/run-pass/deref-lval.rs
@@ -1,3 +1,3 @@
 
 
-fn main() { let x = @mutable 5; *x = 1000; log_full(core::debug, *x); }
+fn main() { let x = @mutable 5; *x = 1000; log(debug, *x); }

diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs
index 768a75878f437bce5be38e89bae35e072200b464..768f2aba16d6f853296d25109bd8cefda68b37ea 100644 (file)
--- a/src/test/run-pass/expr-block-generic-box1.rs
+++ b/src/test/run-pass/expr-block-generic-box1.rs
@@ -11,8 +11,8 @@ fn test_generic<T>(expected: @T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool {
-        log_full(core::debug, *b1);
-        log_full(core::debug, *b2);
+        log(debug, *b1);
+        log(debug, *b2);
         ret *b1 == *b2;
     }
     let eq = bind compare_box(_, _);

diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index 6c61cf619a123278caa2a8c9a7a45aa931b044cc..8942201fa9c26efeab988044fadf126f9e57063d 100644 (file)
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -10,8 +10,8 @@ fn test_generic<copy T>(expected: ~T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: ~bool, b2: ~bool) -> bool {
-        log_full(core::debug, *b1);
-        log_full(core::debug, *b2);
+        log(debug, *b1);
+        log(debug, *b2);
         ret *b1 == *b2;
     }
     let eq = bind compare_box(_, _);

diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs
index 4baf413b4c92976afea6dd1b6487e1e4085c155b..082a7d65bca1296a7d593de25e2d3137f6bde155 100644 (file)
--- a/src/test/run-pass/fact.rs
+++ b/src/test/run-pass/fact.rs
@@ -5,7 +5,7 @@
 fn f(x: int) -> int {
     // #debug("in f:");
 
-    log_full(core::debug, x);
+    log(debug, x);
     if x == 1 {
         // #debug("bottoming out");
 
@@ -16,7 +16,7 @@ fn f(x: int) -> int {
         let y: int = x * f(x - 1);
         // #debug("returned");
 
-        log_full(core::debug, y);
+        log(debug, y);
         ret y;
     }
 }

diff --git a/src/test/run-pass/float-signature.rs b/src/test/run-pass/float-signature.rs
index f0085418fdb9c6971e67768d21877bfd607b7864..c9cfbe40e0eaeb2261065dd20ba05d8737e4e218 100644 (file)
--- a/src/test/run-pass/float-signature.rs
+++ b/src/test/run-pass/float-signature.rs
@@ -4,5 +4,5 @@ fn main() {
     fn foo(n: float) -> float { ret n + 0.12345; }
     let n: float = 0.1;
     let m: float = foo(n);
-    log_full(core::debug, m);
+    log(debug, m);
 }

diff --git a/src/test/run-pass/float.rs b/src/test/run-pass/float.rs
index a57e897f50669e7cecca6e6b9924af70076a44f4..d13e08c7ed3b918accf6b4ccb3143c7afa2b7336 100644 (file)
--- a/src/test/run-pass/float.rs
+++ b/src/test/run-pass/float.rs
@@ -2,7 +2,7 @@
 
 fn main() {
     let pi = 3.1415927;
-    log_full(core::debug, -pi * (pi + 2.0 / pi) - pi * 5.0);
+    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");

diff --git a/src/test/run-pass/fn-constraint.rs b/src/test/run-pass/fn-constraint.rs
index 5a3486538ae3bcee6dc644769b4a04793c60985d..68106f298617f2ccfb8c566982f2e09b7bf86647 100644 (file)
--- a/src/test/run-pass/fn-constraint.rs
+++ b/src/test/run-pass/fn-constraint.rs
@@ -6,5 +6,5 @@ fn main() {
     let a: uint = 1u;
     let b: uint = 4u;
     check (le(a, b));
-    log_full(core::debug, safe_slice("kitties", a, b));
+    log(debug, safe_slice("kitties", a, b));
 }

diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
index 947e0a0a345b74651fb936d1ad5e18a043e58357..5919ee91b441e08b0b8689574e283ac2524a107c 100644 (file)
--- a/src/test/run-pass/foreach-put-structured.rs
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -11,8 +11,8 @@ fn main() {
     let j: int = 0;
     pairs() {|p|
         let (_0, _1) = p;
-        log_full(core::debug, _0);
-        log_full(core::debug, _1);
+        log(debug, _0);
+        log(debug, _1);
         assert (_0 + 10 == i);
         i += 1;
         j = _1;

diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs
index 81b26a42e1be9c89342f8bb9cfa82df230f7cdaf..90356d15b4b8a7de609d65fcb38cfe35da8bf822 100644 (file)
--- a/src/test/run-pass/foreach-simple-outer-slot.rs
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -4,9 +4,9 @@
 // -*- rust -*-
 fn main() {
     let sum: int = 0;
-    first_ten {|i| #debug("main"); log_full(core::debug, i); sum = sum + i; };
+    first_ten {|i| #debug("main"); log(debug, i); sum = sum + i; };
     #debug("sum");
-    log_full(core::debug, sum);
+    log(debug, sum);
     assert (sum == 45);
 }
 

diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 1927895c4a00158cdfaf1b500ee3677a01454500..f44ef370e2ccdb7880510a540d0fd032afb36e53 100644 (file)
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -5,6 +5,6 @@
 fn main() {
     let expected = @100;
     let actual = id::<@int>(expected);
-    log_full(core::debug, *actual);
+    log(debug, *actual);
     assert (*expected == *actual);
 }

diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index afab511d0fee8c0738d9ed519bc8c600a32861dd..4746a588a56b8f8e14ce70cb2fe35cafedfb1332 100644 (file)
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -5,6 +5,6 @@
 fn main() {
     let expected = ~100;
     let actual = id::<~int>(expected);
-    log_full(core::debug, *actual);
+    log(debug, *actual);
     assert (*expected == *actual);
 }

diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index a38673c5e20386f2260090daab2aee6d8aa35a11..032a5c3f9d69e28ba6f6b3dbdc4429367b1fa0ce 100644 (file)
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -11,8 +11,8 @@ fn f<copy T>(t: T) -> {a: T, b: T} {
 
 fn main() {
     let b = f::<int>(10);
-    log_full(core::debug, b.a);
-    log_full(core::debug, b.b);
+    log(debug, b.a);
+    log(debug, b.b);
     assert (b.a == 10);
     assert (b.b == 10);
 }

diff --git a/src/test/run-pass/generic-fn-box.rs b/src/test/run-pass/generic-fn-box.rs
index 51fd9d266a9a26b7bb57cf36f98023203e7ccb0f..4f0bd22944ede3647134cd476a5b60fbcdb36a8b 100644 (file)
--- a/src/test/run-pass/generic-fn-box.rs
+++ b/src/test/run-pass/generic-fn-box.rs
@@ -2,4 +2,4 @@
 
 fn f<T>(x: @T) -> @T { ret x; }
 
-fn main() { let x = f(@3); log_full(core::debug, *x); }
+fn main() { let x = f(@3); log(debug, *x); }

diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index 1da5e7ecbeced112861040f9e27cf3a478f88a65..7333350e3b22d4b92ffa9ae71e7e2448f2cb402e 100644 (file)
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -1,4 +1,4 @@
 
 fn f<copy T>(x: ~T) -> ~T { ret x; }
 
-fn main() { let x = f(~3); log_full(core::debug, *x); }
+fn main() { let x = f(~3); log(debug, *x); }

diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index 64c7d969f23943e6dbfb8a5cb5a828abecde0166..ac2d6f5aad337938d37c2a63d8bb469b7851ee02 100644 (file)
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -14,14 +14,14 @@ fn main() {
     let p: triple = {x: 65, y: 66, z: 67};
     let q: triple = {x: 68, y: 69, z: 70};
     y = id::<int>(x);
-    log_full(core::debug, y);
+    log(debug, y);
     assert (x == y);
     b = id::<char>(a);
-    log_full(core::debug, b);
+    log(debug, b);
     assert (a == b);
     q = id::<triple>(p);
     x = p.z;
     y = q.z;
-    log_full(core::debug, y);
+    log(debug, y);
     assert (x == y);
 }

diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs
index d3d8c4cc98b6f4820def90621f45464c8e2442e1..2186b12022d7ffe8ee7668574c95d67ef017a29b 100644 (file)
--- a/src/test/run-pass/generic-obj-with-derived-type.rs
+++ b/src/test/run-pass/generic-obj-with-derived-type.rs
@@ -9,9 +9,9 @@ fn main() {
 
     let h: handle<rgb> = handle::<rgb>({x: 1 as u8, y: 2 as u8, z: 3 as u8});
     #debug("constructed object");
-    log_full(core::debug, h.get().x);
-    log_full(core::debug, h.get().y);
-    log_full(core::debug, h.get().z);
+    log(debug, h.get().x);
+    log(debug, h.get().y);
+    log(debug, h.get().z);
     assert (h.get().x == 1 as u8);
     assert (h.get().y == 2 as u8);
     assert (h.get().z == 3 as u8);

diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs
index 0b503e50f1faa8b9c481ffebb3ec231463f537af..ab693787182dcf04311b70b2ae823dbf36467422 100644 (file)
--- a/src/test/run-pass/generic-obj.rs
+++ b/src/test/run-pass/generic-obj.rs
@@ -13,9 +13,9 @@ fn take2(t: T) { }
 fn main() {
     let b: buf<int> = buf::<int>({_0: 1, _1: 2, _2: 3});
     #debug("constructed object");
-    log_full(core::debug, b.get(0));
-    log_full(core::debug, b.get(1));
-    log_full(core::debug, b.get(2));
+    log(debug, b.get(0));
+    log(debug, b.get(1));
+    log(debug, b.get(2));
     assert (b.get(0) == 1);
     assert (b.get(1) == 2);
     assert (b.get(2) == 3);

diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs
index ba7f5858b4ea953052a015b8b844eecb4bdb6c6f..7b03e75ef082b0c59bfc87aa50da8b90505472a5 100644 (file)
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -6,12 +6,12 @@
 
 fn main() {
     let nop: noption<int> = some::<int>(5);
-    alt nop { some::<int>(n) { log_full(core::debug, n); assert (n == 5); } }
+    alt nop { some::<int>(n) { log(debug, n); assert (n == 5); } }
     let nop2: noption<{x: int, y: int}> = some({x: 17, y: 42});
     alt nop2 {
       some(t) {
-        log_full(core::debug, t.x);
-        log_full(core::debug, t.y);
+        log(debug, t.x);
+        log(debug, t.y);
         assert (t.x == 17);
         assert (t.y == 42);
       }

diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs
index 954fde38d4de7f084b9b8174ed6bee2d6b7c3c2b..b648583424124b14d92fd22a7438e682d8617614 100644 (file)
--- a/src/test/run-pass/generic-temporary.rs
+++ b/src/test/run-pass/generic-temporary.rs
@@ -2,7 +2,7 @@
 
 fn mk() -> int { ret 1; }
 
-fn chk(&&a: int) { log_full(core::debug, a); assert (a == 1); }
+fn chk(&&a: int) { log(debug, a); assert (a == 1); }
 
 fn apply<T>(produce: fn() -> T, consume: fn(T)) { consume(produce()); }
 

diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index 38cf67b3baa7c1fb55669be68abcf6dcb07f6d88..2b5f81d526d5432e88095fe0d8780281978e8b9d 100644 (file)
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -1,7 +1,7 @@
 fn get_third<copy T>(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; }
 
 fn main() {
-    log_full(core::debug, get_third((1, 2, 3)));
+    log(debug, get_third((1, 2, 3)));
     assert (get_third((1, 2, 3)) == 3);
     assert (get_third((5u8, 6u8, 7u8)) == 7u8);
 }

diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 204fa51730249811a07689bf38f83f622d44580f..8670a53ac335e11befacc9bd6a9b7528fe723a63 100644 (file)
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -52,7 +52,7 @@ fn emit(im: map::hashmap<str, int>, ctrl: chan<ctrl_proto>, key: str,
                 send(ctrl, find_reducer(str::bytes(key), chan(p)));
                 #error("receiving");
                 c = recv(p);
-                log_full(core::error, c);
+                log(error, c);
                 im.insert(key, c);
               }
             }

diff --git a/src/test/run-pass/if-bot.rs b/src/test/run-pass/if-bot.rs
index 78acc18e64357212c60d44a60dfdbdbc770a42fb..11ebbcea822fb32be5dc01687f6e6cf751e28fb5 100644 (file)
--- a/src/test/run-pass/if-bot.rs
+++ b/src/test/run-pass/if-bot.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let i: int = if false { fail } else { 5 };
-    log_full(core::debug, i);
+    log(debug, i);
 }

diff --git a/src/test/run-pass/if-check-precond.rs b/src/test/run-pass/if-check-precond.rs
index 58b61be0b05324c9e427fc6050a25b37a25935bb..f3d35f52a3aa450dc9963aa6eed041e86cceece9 100644 (file)
--- a/src/test/run-pass/if-check-precond.rs
+++ b/src/test/run-pass/if-check-precond.rs
@@ -4,7 +4,7 @@
     } else if x == 2u { ret true; } else { ret even(x - 2u); }
 }
 
-fn print_even(x: uint) : even(x) { log_full(core::debug, x); }
+fn print_even(x: uint) : even(x) { log(debug, x); }
 
 fn foo(x: uint) { if check even(x) { print_even(x); } else { fail; } }
 

diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs
index af41543041baad5c1d3b20a3748c2b64594ffcce..59766164018409e200e5b79f12b0e3e2f89a1397 100644 (file)
--- a/src/test/run-pass/if-check.rs
+++ b/src/test/run-pass/if-check.rs
@@ -6,7 +6,7 @@
 
 fn foo(x: uint) {
     if check even(x) {
-        log_full(core::debug, x);
+        log(debug, x);
     } else {
         fail;
     }

diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index 16a132c1d5d7f80d629e8bc195190546b9ace765..b8a74753895f9124ee5cb83692e0faaefe26036b 100644 (file)
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -3,9 +3,9 @@
 fn main() {
     import vec;
     import vec::to_mut;
-    log_full(core::debug, vec::len(to_mut([1, 2])));
+    log(debug, vec::len(to_mut([1, 2])));
     {
         import vec::*;
-        log_full(core::debug, len([2]));
+        log(debug, len([2]));
     }
 }

diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs
index 68a7d6877d125d0d4ebfd37bd551b248e61f63b6..49a576ac1b17320cc296b4871d67a9ef0155bef6 100644 (file)
--- a/src/test/run-pass/import.rs
+++ b/src/test/run-pass/import.rs
@@ -1,5 +1,5 @@
 mod foo {
-    fn x(y: int) { log_full(core::debug, y); }
+    fn x(y: int) { log(debug, y); }
 }
 
 mod bar {

diff --git a/src/test/run-pass/import8.rs b/src/test/run-pass/import8.rs
index fdaca253e54527fd953f6588bc897978977d15d5..f7d9c761af7478d94956964979a4c297729759db 100644 (file)
--- a/src/test/run-pass/import8.rs
+++ b/src/test/run-pass/import8.rs
@@ -3,7 +3,7 @@
 import z = foo::x;
 
 mod foo {
-    fn x(y: int) { log_full(core::debug, y); }
+    fn x(y: int) { log(debug, y); }
 }
 
 fn main() { x(10); z(10); }

diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
index 81bad1e91d117032059aeebb2244528875dde2cd..0351736b2a3dfe54c7f5b5bae3c0516e25a47699 100644 (file)
--- a/src/test/run-pass/integral-indexing.rs
+++ b/src/test/run-pass/integral-indexing.rs
@@ -10,11 +10,11 @@ fn main() {
     assert (v[3i8] == 3);
     assert (v[3u32] == 3);
     assert (v[3i32] == 3);
-    log_full(core::debug, v[3u8]);
+    log(debug, v[3u8]);
     assert (s[3u] == 'd' as u8);
     assert (s[3u8] == 'd' as u8);
     assert (s[3i8] == 'd' as u8);
     assert (s[3u32] == 'd' as u8);
     assert (s[3i32] == 'd' as u8);
-    log_full(core::debug, s[3u8]);
+    log(debug, s[3u8]);
 }

diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index e30e9cf7ecd0fcc6423e57f65b14e4342c4638b3..716b9dd16db0fb9402dff5a1a9fce0e665ea249e 100644 (file)
--- a/src/test/run-pass/issue-507.rs
+++ b/src/test/run-pass/issue-507.rs
@@ -29,7 +29,7 @@ fn main() {
 
     let x: int = recv(p);
 
-    log_full(core::debug, x);
+    log(debug, x);
 
     assert (x == 42);
 

diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 29c5bfecf27b06c4cc3c4f4e06d2a421d403158f..2c0a2ae7afc719547bd65d81c59d959a5fc2b690 100644 (file)
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -28,7 +28,7 @@ fn packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
             break;
         }
         #debug("sending non-empty buffer of length");
-        log_full(core::debug, vec::len(data));
+        log(debug, vec::len(data));
         send(msg, received(data));
         #debug("sent non-empty buffer");
     }
@@ -51,7 +51,7 @@ fn main() {
           closed. { #debug("Got close message"); break; }
           received(data) {
             #debug("Got data. Length is:");
-            log_full(core::debug, vec::len::<u8>(data));
+            log(debug, vec::len::<u8>(data));
           }
         }
     }

diff --git a/src/test/run-pass/issue-898.rs b/src/test/run-pass/issue-898.rs
index a03e7eaece8ef1428d6581f61e372aaccda14bc5..c01457ed491365f2a75604cef3ba93c496549a87 100644 (file)
--- a/src/test/run-pass/issue-898.rs
+++ b/src/test/run-pass/issue-898.rs
@@ -3,7 +3,7 @@ fn even(&&e: int) -> bool {
 }
 
 fn log_if<T>(c: fn(T)->bool, e: T) {
-    if c(e) { log_full(core::debug, e); }
+    if c(e) { log(debug, e); }
 }
 
 fn main() {

diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs
index 56206422c2eddc1938554fcbb55202a7d6230e63..db54df099672bb8c6d5af16b48684e32224f34c7 100644 (file)
--- a/src/test/run-pass/istr.rs
+++ b/src/test/run-pass/istr.rs
@@ -1,6 +1,6 @@
 fn test_stack_assign() {
     let s: str = "a";
-    log_full(core::debug, s);
+    log(debug, s);
     let t: str = "a";
     assert (s == t);
     let u: str = "b";
@@ -17,7 +17,7 @@ fn test_heap_assign() {
     assert (s != u);
 }
 
-fn test_heap_log() { let s = "a big ol' string"; log_full(core::debug, s); }
+fn test_heap_log() { let s = "a big ol' string"; log(debug, s); }
 
 fn test_stack_add() {
     assert ("a" + "b" == "ab");
@@ -39,7 +39,7 @@ fn test_append() {
 
     let s = "a";
     s += "b";
-    log_full(core::debug, s);
+    log(debug, s);
     assert (s == "ab");
 
     let s = "c";

diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs
index d549b247933e6621f7fcc5ca3aa02b0e06b3e034..c02fc34ae8b7708fbcb77f62e67f5b07c7935c50 100644 (file)
--- a/src/test/run-pass/iter-range.rs
+++ b/src/test/run-pass/iter-range.rs
@@ -9,5 +9,5 @@ fn range(a: int, b: int, it: block(int)) {
 fn main() {
     let sum: int = 0;
     range(0, 100) {|x| sum += x; }
-    log_full(core::debug, sum);
+    log(debug, sum);
 }

diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index 3ccf97aba52d03abe8c4f293f764d8013223bd96..87dc1e6d89be529c27a9beb18a921205990ad236 100644 (file)
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -2,6 +2,6 @@
 // resolved when we finish typechecking the lambda.
 fn main() {
     let e = @{mutable refs: [], n: 0};
-    let f = lambda () { log_full(core::error, e.n); };
+    let f = lambda () { log(error, e.n); };
     e.refs += [1];
 }

diff --git a/src/test/run-pass/lambda-no-leak.rs b/src/test/run-pass/lambda-no-leak.rs
index 17d0eda392b897bb7df55959fc7f414769dffcf0..0eeb306d4fda370490537601a0a6690281f3f5a4 100644 (file)
--- a/src/test/run-pass/lambda-no-leak.rs
+++ b/src/test/run-pass/lambda-no-leak.rs
@@ -2,6 +2,6 @@
 fn force(f: fn@()) { f() }
 fn main() {
     let x = 7;
-    lambda () { log_full(core::error, x); };
-    force(lambda () { log_full(core::error, x); });
+    lambda () { log(error, x); };
+    force(lambda () { log(error, x); });
 }

diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
index 9aef748ce09496f601942af234b5f8ee59d2c0fa..2639e9e2a0a18049ee7c3d8ea7314a4fb9b3be17 100644 (file)
--- a/src/test/run-pass/lazy-and-or.rs
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -6,7 +6,7 @@ fn main() {
     let x = 1 == 2 || 3 == 3;
     assert (x);
     let y: int = 10;
-    log_full(core::debug, x || incr(y));
+    log(debug, x || incr(y));
     assert (y == 10);
     if true && x { assert (true); } else { assert (false); }
 }

diff --git a/src/test/run-pass/lazy-init.rs b/src/test/run-pass/lazy-init.rs
index fb0a9979c64eab3df9caf2df5a13296cacb469dd..392665eee067150e05802988484a0773ba59952a 100644 (file)
--- a/src/test/run-pass/lazy-init.rs
+++ b/src/test/run-pass/lazy-init.rs
@@ -1,5 +1,5 @@
 
 
-fn foo(x: int) { log_full(core::debug, x); }
+fn foo(x: int) { log(debug, x); }
 
 fn main() { let x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }

diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 5bf47adcf06ce85c5ab68883b87fea5c26d6c3e7..67ec699e070105b2c9280cf43b5df1dc3a8fe5af 100644 (file)
--- a/src/test/run-pass/lazychan.rs
+++ b/src/test/run-pass/lazychan.rs
@@ -11,13 +11,13 @@ fn main() {
     task::spawn(chan(p), child);
     y = recv(p);
     #debug("received 1");
-    log_full(core::debug, y);
+    log(debug, y);
     assert (y == 10);
 
     task::spawn(chan(p), child);
     y = recv(p);
     #debug("received 2");
-    log_full(core::debug, y);
+    log(debug, y);
     assert (y == 10);
 }
 

diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index de87837a31aace531fd5f37442927d32a31979e0..d36551c723e885a1fb8c2eb48522fcd64e46db18 100644 (file)
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -3,8 +3,8 @@
 fn main() {
     let x = [1, 2, 3];
     let y = 0;
-    for i: int in x { log_full(core::debug, i); y += i; }
-    log_full(core::debug, y);
+    for i: int in x { log(debug, i); y += i; }
+    log(debug, y);
     assert (y == 6);
     let s = "hello there";
     let i: int = 0;
@@ -17,8 +17,8 @@ fn main() {
         // ...
 
         i += 1;
-        log_full(core::debug, i);
-        log_full(core::debug, c);
+        log(debug, i);
+        log(debug, c);
     }
     assert (i == 11);
 }

diff --git a/src/test/run-pass/log-err-phi.rs b/src/test/run-pass/log-err-phi.rs
index 305f84d766c416baff5a5e2fb714f52a1ec9e45a..5b4ae8799c8e03be256515e2e501912543af74a4 100644 (file)
--- a/src/test/run-pass/log-err-phi.rs
+++ b/src/test/run-pass/log-err-phi.rs
@@ -1,3 +1,3 @@
 
 
-fn main() { if false { log_full(core::error, "foo" + "bar"); } }
+fn main() { if false { log(error, "foo" + "bar"); } }

diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs
index 88603bd1f7b7f11bf09c8f4f392afa90f04e4bb2..984683d8ad22d18693b0f9dadb6ba8909f3c72f5 100644 (file)
--- a/src/test/run-pass/log-linearized.rs
+++ b/src/test/run-pass/log-linearized.rs
@@ -14,7 +14,7 @@ fn mk<T>() -> smallintmap<T> {
 
 fn f<T,U>() {
     let sim = mk::<U>();
-    log_full(core::error, sim);
+    log(error, sim);
 }
 
 fn main() {

diff --git a/src/test/run-pass/main-ivec.rs b/src/test/run-pass/main-ivec.rs
index c4d74b651710220ae5424d2319b41a048c221513..856682dca07c5395d398a44a495abf942febc4f4 100644 (file)
--- a/src/test/run-pass/main-ivec.rs
+++ b/src/test/run-pass/main-ivec.rs
@@ -1 +1 @@
-fn main(args: [str]) { for s in args { log_full(core::debug, s); } }
+fn main(args: [str]) { for s in args { log(debug, s); } }

diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index feb95f7e363bb2a6768868d72305475dbd94cd96..044e77d5f1e153dc6bb8b3c47801c9709545a548 100644 (file)
--- a/src/test/run-pass/many.rs
+++ b/src/test/run-pass/many.rs
@@ -21,6 +21,6 @@ fn main() {
     let child = task::spawn((comm::chan(p), 200), sub);
     let y = comm::recv(p);
     #debug("transmission complete");
-    log_full(core::debug, y);
+    log(debug, y);
     assert (y == 200);
 }

diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
index 05ebb5ac50f2e697b6456c7a4aabc18cc7e3ba9e..e5afe657142f58d3a92276b9d10b6cbed591bd79 100644 (file)
--- a/src/test/run-pass/maybe-mutable.rs
+++ b/src/test/run-pass/maybe-mutable.rs
@@ -10,7 +10,7 @@ fn len(v: [const int]) -> uint {
 
 fn main() {
     let v0 = [1, 2, 3, 4, 5];
-    log_full(core::debug, len(v0));
+    log(debug, len(v0));
     let v1 = [mutable 1, 2, 3, 4, 5];
-    log_full(core::debug, len(v1));
+    log(debug, len(v1));
 }

diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 596103af7fc46378a3c6b6391e076ef41c8a925e..f0493017671684c2338dc620997405bacf03ec6b 100644 (file)
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -11,6 +11,6 @@ fn main() {
     grow(v);
     grow(v);
     let len = vec::len::<int>(v);
-    log_full(core::debug, len);
+    log(debug, len);
     assert (len == 3 as uint);
 }

diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs
index c07b4ab97a6dde9055347e1331c3e160ea314b13..09481d7e08438bc6ccd29a3133bd54e808bb24d3 100644 (file)
--- a/src/test/run-pass/nested-alts.rs
+++ b/src/test/run-pass/nested-alts.rs
@@ -6,7 +6,7 @@ fn foo() {
       some::<int>(x) {
         let bar;
         alt none::<int> { none::<int>. { bar = 5; } _ { baz(); } }
-        log_full(core::debug, bar);
+        log(debug, bar);
       }
       none::<int>. { #debug("hello"); }
     }

diff --git a/src/test/run-pass/obj-recursion.rs b/src/test/run-pass/obj-recursion.rs
index c37a03ed8385ae26b69cd0cc8a2ab9890d19b4be..f1f998b376f1aacedf73cba50a12a46c3cbacbbb 100644 (file)
--- a/src/test/run-pass/obj-recursion.rs
+++ b/src/test/run-pass/obj-recursion.rs
@@ -6,7 +6,7 @@
     };
 
 obj leaf_adder(x: int) {
-    fn add() { #debug("leaf"); log_full(core::debug, x); }
+    fn add() { #debug("leaf"); log(debug, x); }
 }
 
 obj delegate_adder(a: adder) {

diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs
index 1670febe0e49898cbb32530ed44f633a489ec0a9..5ceab392c2e914c6e0a4aa99e99bcd5faa9eb63d 100644 (file)
--- a/src/test/run-pass/obj-with-vec.rs
+++ b/src/test/run-pass/obj-with-vec.rs
@@ -5,6 +5,6 @@ fn main() {
         fn get(i: int) -> u8 { ret data[i]; }
     }
     let b = buf([1 as u8, 2 as u8, 3 as u8]);
-    log_full(core::debug, b.get(1));
+    log(debug, b.get(1));
     assert (b.get(1) == 2 as u8);
 }

diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs
index 96214d9669fdf4b29c210ea0a6a14a589bb0c614..75fb607b866f8935558f77a1274b07d037a41c03 100644 (file)
--- a/src/test/run-pass/opeq.rs
+++ b/src/test/run-pass/opeq.rs
@@ -5,15 +5,15 @@
 fn main() {
     let x: int = 1;
     x *= 2;
-    log_full(core::debug, x);
+    log(debug, x);
     assert (x == 2);
     x += 3;
-    log_full(core::debug, x);
+    log(debug, x);
     assert (x == 5);
     x *= x;
-    log_full(core::debug, x);
+    log(debug, x);
     assert (x == 25);
     x /= 5;
-    log_full(core::debug, x);
+    log(debug, x);
     assert (x == 5);
 }

diff --git a/src/test/run-pass/over-constrained-vregs.rs b/src/test/run-pass/over-constrained-vregs.rs
index 064d1e47347a4e5db07dd78a16734bc6f8a9d6a2..b2bea85db4c05a76d6551e994563265b12e5297f 100644 (file)
--- a/src/test/run-pass/over-constrained-vregs.rs
+++ b/src/test/run-pass/over-constrained-vregs.rs
@@ -7,6 +7,6 @@ fn main() {
     while b <= 32u {
         0u << b;
         b <<= 1u;
-        log_full(core::debug, b);
+        log(debug, b);
     }
 }

diff --git a/src/test/run-pass/parse-fail.rs b/src/test/run-pass/parse-fail.rs
index b9bcc80e486f862b1efde1d514dd2911241a6f98..e6a14e9128d5b4c5b1900dbe249c71f9176244bb 100644 (file)
--- a/src/test/run-pass/parse-fail.rs
+++ b/src/test/run-pass/parse-fail.rs
@@ -2,6 +2,6 @@
 
 
 // -*- rust -*-
-fn dont_call_me() { fail; log_full(core::debug, 1); }
+fn dont_call_me() { fail; log(debug, 1); }
 
 fn main() { }

diff --git a/src/test/run-pass/pass-by-copy.rs b/src/test/run-pass/pass-by-copy.rs
index b9eecbed2f100809643bd60b246bd00e7cd1f581..98a137d3eb57ae8915fc2e111c395ae7a5019693 100644 (file)
--- a/src/test/run-pass/pass-by-copy.rs
+++ b/src/test/run-pass/pass-by-copy.rs
@@ -1,5 +1,5 @@
-fn magic(+x: {a: @int}) { log_full(core::debug, x); }
-fn magic2(+x: @int) { log_full(core::debug, x); }
+fn magic(+x: {a: @int}) { log(debug, x); }
+fn magic2(+x: @int) { log(debug, x); }
 
 fn main() {
     let a = {a: @10}, b = @10;

diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs
index 73ada106f430990f3a093a34fd53623ca5f3aa9c..8b2274817f74c0e2cea80f1e20ed375c7c054a69 100644 (file)
--- a/src/test/run-pass/rec-auto.rs
+++ b/src/test/run-pass/rec-auto.rs
@@ -6,6 +6,6 @@
 // Issue #50.
 fn main() {
     let x = {foo: "hello", bar: "world"};
-    log_full(core::debug, x.foo);
-    log_full(core::debug, x.bar);
+    log(debug, x.foo);
+    log(debug, x.bar);
 }

diff --git a/src/test/run-pass/reference-branch.rs b/src/test/run-pass/reference-branch.rs
index 56f70a64576a065e25039a0e4497baf8f3b01719..20e4f27627edc520c7047ed95ea4515749feeff1 100644 (file)
--- a/src/test/run-pass/reference-branch.rs
+++ b/src/test/run-pass/reference-branch.rs
@@ -5,5 +5,5 @@ fn main() {
     let x = [];
     let &y = x;
     if true { x = [1]; }
-    else { log_full(core::error, y); }
+    else { log(error, y); }
 }

diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs
index 9348dcd50c2c9f51392b9c42ee4708af3af27075..1261878db2e633f897965cda617741d26a91d4f5 100644 (file)
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -7,7 +7,7 @@ fn main() {
         let a = r(i);
         let b = (a, 10);
         let (c, _d) = b;
-        log_full(core::debug, c);
+        log(debug, c);
     }
     assert *i == 1;
 }

diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs
index e3609bf1d761e97e1a984b784038d490c602f5b9..db8b86fe4a4173bde1cf80a3e831125a8d5ea688 100644 (file)
--- a/src/test/run-pass/ret-bang.rs
+++ b/src/test/run-pass/ret-bang.rs
@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-fn my_err(s: str) -> ! { log_full(core::error, s); fail; }
+fn my_err(s: str) -> ! { log(error, s); fail; }
 
 fn okay(i: uint) -> int {
     if i == 3u { my_err("I don't like three"); } else { ret 42; }

diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs
index 5a6255038f6b42737e404183c9c47c84cdbd5ca6..3c19958fa3110690dc57a3844a8c98c09900ebf8 100644 (file)
--- a/src/test/run-pass/sendfn-generic-fn.rs
+++ b/src/test/run-pass/sendfn-generic-fn.rs
@@ -14,12 +14,12 @@ fn make_generic_record<copy A,copy B>(a: A, b: B) -> pair<A,B> {
 
 fn test05_start(&&f: sendfn(&&float, &&str) -> pair<float, str>) {
     let p = f(22.22f, "Hi");
-    log_full(core::debug, p);
+    log(debug, p);
     assert p.a == 22.22f;
     assert p.b == "Hi";
 
     let q = f(44.44f, "Ho");
-    log_full(core::debug, q);
+    log(debug, q);
     assert q.a == 44.44f;
     assert q.b == "Ho";
 }

diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index 2edc604deb871214434dc761cf61e51892c8f0eb..84bc0759502114ca08517f515987b8efdf3673b3 100644 (file)
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -13,7 +13,7 @@ fn test05_start(&&f: sendfn(int)) {
 fn test05() {
     let three = ~3;
     let fn_to_send = sendfn(n: int) {
-        log_full(core::error, *three + n); // will copy x into the closure
+        log(error, *three + n); // will copy x into the closure
         assert(*three == 3);
     };
     task::spawn(fn_to_send, test05_start);

diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index 1a693bc3b1a7a513f32c1f4cf1b3eb53fe3a41ae..dd430bc7089c47161c60fafebebfc04925cc9715 100644 (file)
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -7,7 +7,7 @@ fn foo(c: [int]) {
     alt none::<int> {
       some::<int>(_) {
         for i: int in c {
-            log_full(core::debug, a);
+            log(debug, a);
             let a = 17;
             b += [a];
         }

diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
index 9132f65077248e5d67527e308f98d15052328dfe..a50e5ed82d74d17051a3d3848e2cf8f58fe5cbb2 100644 (file)
--- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
+++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
@@ -26,6 +26,6 @@ fn main() {
     let p_: path_ = { global: true, idents: ["hi"], types: [t] };
     let p: path = { data: p_, span: sp };
     let x = { sp: sp, path: p };
-    log_full(core::error, x.path);
-    log_full(core::error, x);
+    log(error, x.path);
+    log(error, x);
 }

diff --git a/src/test/run-pass/simple-infer.rs b/src/test/run-pass/simple-infer.rs
index 887df2ef3f39787d4eccdc0f7fd3b7c9d3bda457..e320d1b6d01ecdb0eff2cf91e2d5106f999916b0 100644 (file)
--- a/src/test/run-pass/simple-infer.rs
+++ b/src/test/run-pass/simple-infer.rs
@@ -1,3 +1,3 @@
 
 
-fn main() { let n; n = 1; log_full(core::debug, n); }
+fn main() { let n; n = 1; log(debug, n); }

diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index 38e473f082ce64057ebc90a8a74191bac985e315..d0c4a2f270b9a679495fdd9c78ff68a09a8c9a64 100644 (file)
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -6,7 +6,7 @@
 
 fn uhoh<T>(v: [clam<T>]) {
     alt v[1] {
-      a::<T>(t, u) { #debug("incorrect"); log_full(core::debug, u); fail; }
+      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 38600ba9f7eacc4c763bf60e02e85e8f50752da5..68e0f22f2f83ebaf3d6fbea2568cd144149fa828 100644 (file)
--- a/src/test/run-pass/spawn-fn.rs
+++ b/src/test/run-pass/spawn-fn.rs
@@ -6,7 +6,7 @@
 
 fn x(&&args: (str, int)) {
     let (s, n) = args;
-    log_full(core::debug, s); log_full(core::debug, n);
+    log(debug, s); log(debug, n);
 }
 
 fn main() {

diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index 664f3e33b061dc7643696d555d76881e9abc1c7b..413474efd929f4a0d272085f0af1483655f307c1 100644 (file)
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -5,5 +5,5 @@
 fn main() { let x = spawn_joinable(10, m::child); join(x); }
 
 mod m {
-    fn child(&&i: int) { log_full(core::debug, i); }
+    fn child(&&i: int) { log(debug, i); }
 }

diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index 431eee700d13a22470f52afa3505842ebf09dcd2..52ceb4c27abef239553db7029e5008153d1ae7af 100644 (file)
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -6,7 +6,7 @@
 
 fn main() { let t = task::spawn_joinable(10, child); task::join(t); }
 
-fn child(&&i: int) { log_full(core::error, i); assert (i == 10); }
+fn child(&&i: int) { log(error, i); assert (i == 10); }
 
 // Local Variables:
 // mode: rust;

diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 1ecc5e8b3b9e8d989a03f817013e2245765e3d21..6d22149824fd89b09d5dfc2fe26a63283e6818d0 100644 (file)
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -7,15 +7,15 @@
 
 fn child(&&args: (int, int, int, int, int, int, int, int, int)) {
     let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
-    log_full(core::error, i1);
-    log_full(core::error, i2);
-    log_full(core::error, i3);
-    log_full(core::error, i4);
-    log_full(core::error, i5);
-    log_full(core::error, i6);
-    log_full(core::error, i7);
-    log_full(core::error, i8);
-    log_full(core::error, i9);
+    log(error, i1);
+    log(error, i2);
+    log(error, i3);
+    log(error, i4);
+    log(error, i5);
+    log(error, i6);
+    log(error, i7);
+    log(error, i8);
+    log(error, i9);
     assert (i1 == 10);
     assert (i2 == 20);
     assert (i3 == 30);

diff --git a/src/test/run-pass/stateful-obj.rs b/src/test/run-pass/stateful-obj.rs
index 8176b30f9f2c77feea5ff4ab091795254889b031..102a226e2986789f2953ee6d0e60eac8fe65331e 100644 (file)
--- a/src/test/run-pass/stateful-obj.rs
+++ b/src/test/run-pass/stateful-obj.rs
@@ -11,9 +11,9 @@
 fn main() {
     let y = counter(0);
     assert (y.hello() == 12345);
-    log_full(core::debug, y.get());
+    log(debug, y.get());
     y.incr();
     y.incr();
-    log_full(core::debug, y.get());
+    log(debug, y.get());
     assert (y.get() == 2);
 }

diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index 5b6b36ba4d650c83ccde2b2c3f7c35a49f5b8b52..dd689afff95324ea0379c3b1d23d15e3f1b45f82 100644 (file)
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -7,7 +7,7 @@
 fn test1() {
     let s: str = "hello";
     s += "world";
-    log_full(core::debug, s);
+    log(debug, s);
     assert (s[9] == 'd' as u8);
 }
 
@@ -17,8 +17,8 @@ fn test2() {
     let ff: str = "abc";
     let a: str = ff + "ABC" + ff;
     let b: str = "ABC" + ff + "ABC";
-    log_full(core::debug, a);
-    log_full(core::debug, b);
+    log(debug, a);
+    log(debug, b);
     assert (str::eq(a, "abcABCabc"));
     assert (str::eq(b, "ABCabcABC"));
 }

diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
index 69ea90b126caf00d6b374028aa9e96c0dfb05a69..69d26469677c22709db24119cdec61bc7d103a24 100644 (file)
--- a/src/test/run-pass/str-concat.rs
+++ b/src/test/run-pass/str-concat.rs
@@ -6,6 +6,6 @@ fn main() {
     let a: str = "hello";
     let b: str = "world";
     let s: str = a + b;
-    log_full(core::debug, s);
+    log(debug, s);
     assert (s[9] == 'd' as u8);
 }

diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs
index 5911cb30e1bfba9c7157a934d21b0a6f9f0f2c15..ef7e2c71eaa44a89a0d715a4e7cde0659762a33e 100644 (file)
--- a/src/test/run-pass/str-idx.rs
+++ b/src/test/run-pass/str-idx.rs
@@ -3,6 +3,6 @@
 fn main() {
     let s = "hello";
     let c: u8 = s[4];
-    log_full(core::debug, c);
+    log(debug, c);
     assert (c == 0x6f as u8);
 }

diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index 34d867e30b6f5d1781d341b97c3392cab1a771c4..30ea8e0efc4372744fa064f2b89ca8398ff99fa9 100644 (file)
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -7,7 +7,7 @@ fn main() {
     let i = 20;
     let expected_len = 1u;
     while i > 0 {
-        log_full(core::error, str::byte_len(a));
+        log(error, str::byte_len(a));
         assert (str::byte_len(a) == expected_len);
         a += a;
         i -= 1;

diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs
index 9612a7749cbe53c1c8532e45ca6ee80b01f76324..de9dffbaca33951a3cfa81eabda68e9115464867 100644 (file)
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -3,251 +3,251 @@
 
 fn main() {
   let f = 1 as os::libc::FILE;
-  log_full(core::debug, f as int);
-  log_full(core::debug, f as uint);
-  log_full(core::debug, f as i8);
-  log_full(core::debug, f as i16);
-  log_full(core::debug, f as i32);
-  log_full(core::debug, f as i64);
-  log_full(core::debug, f as u8);
-  log_full(core::debug, f as u16);
-  log_full(core::debug, f as u32);
-  log_full(core::debug, f as u64);
-
-  log_full(core::debug, 1 as int);
-  log_full(core::debug, 1 as uint);
-  log_full(core::debug, 1 as float);
-  log_full(core::debug, 1 as bool);
-  log_full(core::debug, 1 as os::libc::FILE);
-  log_full(core::debug, 1 as i8);
-  log_full(core::debug, 1 as i16);
-  log_full(core::debug, 1 as i32);
-  log_full(core::debug, 1 as i64);
-  log_full(core::debug, 1 as u8);
-  log_full(core::debug, 1 as u16);
-  log_full(core::debug, 1 as u32);
-  log_full(core::debug, 1 as u64);
-  log_full(core::debug, 1 as f32);
-  log_full(core::debug, 1 as f64);
-
-  log_full(core::debug, 1u as int);
-  log_full(core::debug, 1u as uint);
-  log_full(core::debug, 1u as float);
-  log_full(core::debug, 1u as bool);
-  log_full(core::debug, 1u as os::libc::FILE);
-  log_full(core::debug, 1u as i8);
-  log_full(core::debug, 1u as i16);
-  log_full(core::debug, 1u as i32);
-  log_full(core::debug, 1u as i64);
-  log_full(core::debug, 1u as u8);
-  log_full(core::debug, 1u as u16);
-  log_full(core::debug, 1u as u32);
-  log_full(core::debug, 1u as u64);
-  log_full(core::debug, 1u as f32);
-  log_full(core::debug, 1u as f64);
-
-  log_full(core::debug, 1i8 as int);
-  log_full(core::debug, 1i8 as uint);
-  log_full(core::debug, 1i8 as float);
-  log_full(core::debug, 1i8 as bool);
-  log_full(core::debug, 1i8 as os::libc::FILE);
-  log_full(core::debug, 1i8 as i8);
-  log_full(core::debug, 1i8 as i16);
-  log_full(core::debug, 1i8 as i32);
-  log_full(core::debug, 1i8 as i64);
-  log_full(core::debug, 1i8 as u8);
-  log_full(core::debug, 1i8 as u16);
-  log_full(core::debug, 1i8 as u32);
-  log_full(core::debug, 1i8 as u64);
-  log_full(core::debug, 1i8 as f32);
-  log_full(core::debug, 1i8 as f64);
-
-  log_full(core::debug, 1u8 as int);
-  log_full(core::debug, 1u8 as uint);
-  log_full(core::debug, 1u8 as float);
-  log_full(core::debug, 1u8 as bool);
-  log_full(core::debug, 1u8 as os::libc::FILE);
-  log_full(core::debug, 1u8 as i8);
-  log_full(core::debug, 1u8 as i16);
-  log_full(core::debug, 1u8 as i32);
-  log_full(core::debug, 1u8 as i64);
-  log_full(core::debug, 1u8 as u8);
-  log_full(core::debug, 1u8 as u16);
-  log_full(core::debug, 1u8 as u32);
-  log_full(core::debug, 1u8 as u64);
-  log_full(core::debug, 1u8 as f32);
-  log_full(core::debug, 1u8 as f64);
-
-  log_full(core::debug, 1i16 as int);
-  log_full(core::debug, 1i16 as uint);
-  log_full(core::debug, 1i16 as float);
-  log_full(core::debug, 1i16 as bool);
-  log_full(core::debug, 1i16 as os::libc::FILE);
-  log_full(core::debug, 1i16 as i8);
-  log_full(core::debug, 1i16 as i16);
-  log_full(core::debug, 1i16 as i32);
-  log_full(core::debug, 1i16 as i64);
-  log_full(core::debug, 1i16 as u8);
-  log_full(core::debug, 1i16 as u16);
-  log_full(core::debug, 1i16 as u32);
-  log_full(core::debug, 1i16 as u64);
-  log_full(core::debug, 1i16 as f32);
-  log_full(core::debug, 1i16 as f64);
-
-  log_full(core::debug, 1u16 as int);
-  log_full(core::debug, 1u16 as uint);
-  log_full(core::debug, 1u16 as float);
-  log_full(core::debug, 1u16 as bool);
-  log_full(core::debug, 1u16 as os::libc::FILE);
-  log_full(core::debug, 1u16 as i8);
-  log_full(core::debug, 1u16 as i16);
-  log_full(core::debug, 1u16 as i32);
-  log_full(core::debug, 1u16 as i64);
-  log_full(core::debug, 1u16 as u8);
-  log_full(core::debug, 1u16 as u16);
-  log_full(core::debug, 1u16 as u32);
-  log_full(core::debug, 1u16 as u64);
-  log_full(core::debug, 1u16 as f32);
-  log_full(core::debug, 1u16 as f64);
-
-  log_full(core::debug, 1i32 as int);
-  log_full(core::debug, 1i32 as uint);
-  log_full(core::debug, 1i32 as float);
-  log_full(core::debug, 1i32 as bool);
-  log_full(core::debug, 1i32 as os::libc::FILE);
-  log_full(core::debug, 1i32 as i8);
-  log_full(core::debug, 1i32 as i16);
-  log_full(core::debug, 1i32 as i32);
-  log_full(core::debug, 1i32 as i64);
-  log_full(core::debug, 1i32 as u8);
-  log_full(core::debug, 1i32 as u16);
-  log_full(core::debug, 1i32 as u32);
-  log_full(core::debug, 1i32 as u64);
-  log_full(core::debug, 1i32 as f32);
-  log_full(core::debug, 1i32 as f64);
-
-  log_full(core::debug, 1u32 as int);
-  log_full(core::debug, 1u32 as uint);
-  log_full(core::debug, 1u32 as float);
-  log_full(core::debug, 1u32 as bool);
-  log_full(core::debug, 1u32 as os::libc::FILE);
-  log_full(core::debug, 1u32 as i8);
-  log_full(core::debug, 1u32 as i16);
-  log_full(core::debug, 1u32 as i32);
-  log_full(core::debug, 1u32 as i64);
-  log_full(core::debug, 1u32 as u8);
-  log_full(core::debug, 1u32 as u16);
-  log_full(core::debug, 1u32 as u32);
-  log_full(core::debug, 1u32 as u64);
-  log_full(core::debug, 1u32 as f32);
-  log_full(core::debug, 1u32 as f64);
-
-  log_full(core::debug, 1i64 as int);
-  log_full(core::debug, 1i64 as uint);
-  log_full(core::debug, 1i64 as float);
-  log_full(core::debug, 1i64 as bool);
-  log_full(core::debug, 1i64 as os::libc::FILE);
-  log_full(core::debug, 1i64 as i8);
-  log_full(core::debug, 1i64 as i16);
-  log_full(core::debug, 1i64 as i32);
-  log_full(core::debug, 1i64 as i64);
-  log_full(core::debug, 1i64 as u8);
-  log_full(core::debug, 1i64 as u16);
-  log_full(core::debug, 1i64 as u32);
-  log_full(core::debug, 1i64 as u64);
-  log_full(core::debug, 1i64 as f32);
-  log_full(core::debug, 1i64 as f64);
-
-  log_full(core::debug, 1u64 as int);
-  log_full(core::debug, 1u64 as uint);
-  log_full(core::debug, 1u64 as float);
-  log_full(core::debug, 1u64 as bool);
-  log_full(core::debug, 1u64 as os::libc::FILE);
-  log_full(core::debug, 1u64 as i8);
-  log_full(core::debug, 1u64 as i16);
-  log_full(core::debug, 1u64 as i32);
-  log_full(core::debug, 1u64 as i64);
-  log_full(core::debug, 1u64 as u8);
-  log_full(core::debug, 1u64 as u16);
-  log_full(core::debug, 1u64 as u32);
-  log_full(core::debug, 1u64 as u64);
-  log_full(core::debug, 1u64 as f32);
-  log_full(core::debug, 1u64 as f64);
-
-  log_full(core::debug, 1u64 as int);
-  log_full(core::debug, 1u64 as uint);
-  log_full(core::debug, 1u64 as float);
-  log_full(core::debug, 1u64 as bool);
-  log_full(core::debug, 1u64 as os::libc::FILE);
-  log_full(core::debug, 1u64 as i8);
-  log_full(core::debug, 1u64 as i16);
-  log_full(core::debug, 1u64 as i32);
-  log_full(core::debug, 1u64 as i64);
-  log_full(core::debug, 1u64 as u8);
-  log_full(core::debug, 1u64 as u16);
-  log_full(core::debug, 1u64 as u32);
-  log_full(core::debug, 1u64 as u64);
-  log_full(core::debug, 1u64 as f32);
-  log_full(core::debug, 1u64 as f64);
-
-  log_full(core::debug, true as int);
-  log_full(core::debug, true as uint);
-  log_full(core::debug, true as float);
-  log_full(core::debug, true as bool);
-  log_full(core::debug, true as os::libc::FILE);
-  log_full(core::debug, true as i8);
-  log_full(core::debug, true as i16);
-  log_full(core::debug, true as i32);
-  log_full(core::debug, true as i64);
-  log_full(core::debug, true as u8);
-  log_full(core::debug, true as u16);
-  log_full(core::debug, true as u32);
-  log_full(core::debug, true as u64);
-  log_full(core::debug, true as f32);
-  log_full(core::debug, true as f64);
-
-  log_full(core::debug, 1. as int);
-  log_full(core::debug, 1. as uint);
-  log_full(core::debug, 1. as float);
-  log_full(core::debug, 1. as bool);
-  log_full(core::debug, 1. as i8);
-  log_full(core::debug, 1. as i16);
-  log_full(core::debug, 1. as i32);
-  log_full(core::debug, 1. as i64);
-  log_full(core::debug, 1. as u8);
-  log_full(core::debug, 1. as u16);
-  log_full(core::debug, 1. as u32);
-  log_full(core::debug, 1. as u64);
-  log_full(core::debug, 1. as f32);
-  log_full(core::debug, 1. as f64);
-
-  log_full(core::debug, 1f32 as int);
-  log_full(core::debug, 1f32 as uint);
-  log_full(core::debug, 1f32 as float);
-  log_full(core::debug, 1f32 as bool);
-  log_full(core::debug, 1f32 as i8);
-  log_full(core::debug, 1f32 as i16);
-  log_full(core::debug, 1f32 as i32);
-  log_full(core::debug, 1f32 as i64);
-  log_full(core::debug, 1f32 as u8);
-  log_full(core::debug, 1f32 as u16);
-  log_full(core::debug, 1f32 as u32);
-  log_full(core::debug, 1f32 as u64);
-  log_full(core::debug, 1f32 as f32);
-  log_full(core::debug, 1f32 as f64);
-
-  log_full(core::debug, 1f64 as int);
-  log_full(core::debug, 1f64 as uint);
-  log_full(core::debug, 1f64 as float);
-  log_full(core::debug, 1f64 as bool);
-  log_full(core::debug, 1f64 as i8);
-  log_full(core::debug, 1f64 as i16);
-  log_full(core::debug, 1f64 as i32);
-  log_full(core::debug, 1f64 as i64);
-  log_full(core::debug, 1f64 as u8);
-  log_full(core::debug, 1f64 as u16);
-  log_full(core::debug, 1f64 as u32);
-  log_full(core::debug, 1f64 as u64);
-  log_full(core::debug, 1f64 as f32);
-  log_full(core::debug, 1f64 as f64);
+  log(debug, f as int);
+  log(debug, f as uint);
+  log(debug, f as i8);
+  log(debug, f as i16);
+  log(debug, f as i32);
+  log(debug, f as i64);
+  log(debug, f as u8);
+  log(debug, f as u16);
+  log(debug, f as u32);
+  log(debug, f as u64);
+
+  log(debug, 1 as int);
+  log(debug, 1 as uint);
+  log(debug, 1 as float);
+  log(debug, 1 as bool);
+  log(debug, 1 as os::libc::FILE);
+  log(debug, 1 as i8);
+  log(debug, 1 as i16);
+  log(debug, 1 as i32);
+  log(debug, 1 as i64);
+  log(debug, 1 as u8);
+  log(debug, 1 as u16);
+  log(debug, 1 as u32);
+  log(debug, 1 as u64);
+  log(debug, 1 as f32);
+  log(debug, 1 as f64);
+
+  log(debug, 1u as int);
+  log(debug, 1u as uint);
+  log(debug, 1u as float);
+  log(debug, 1u as bool);
+  log(debug, 1u as os::libc::FILE);
+  log(debug, 1u as i8);
+  log(debug, 1u as i16);
+  log(debug, 1u as i32);
+  log(debug, 1u as i64);
+  log(debug, 1u as u8);
+  log(debug, 1u as u16);
+  log(debug, 1u as u32);
+  log(debug, 1u as u64);
+  log(debug, 1u as f32);
+  log(debug, 1u as f64);
+
+  log(debug, 1i8 as int);
+  log(debug, 1i8 as uint);
+  log(debug, 1i8 as float);
+  log(debug, 1i8 as bool);
+  log(debug, 1i8 as os::libc::FILE);
+  log(debug, 1i8 as i8);
+  log(debug, 1i8 as i16);
+  log(debug, 1i8 as i32);
+  log(debug, 1i8 as i64);
+  log(debug, 1i8 as u8);
+  log(debug, 1i8 as u16);
+  log(debug, 1i8 as u32);
+  log(debug, 1i8 as u64);
+  log(debug, 1i8 as f32);
+  log(debug, 1i8 as f64);
+
+  log(debug, 1u8 as int);
+  log(debug, 1u8 as uint);
+  log(debug, 1u8 as float);
+  log(debug, 1u8 as bool);
+  log(debug, 1u8 as os::libc::FILE);
+  log(debug, 1u8 as i8);
+  log(debug, 1u8 as i16);
+  log(debug, 1u8 as i32);
+  log(debug, 1u8 as i64);
+  log(debug, 1u8 as u8);
+  log(debug, 1u8 as u16);
+  log(debug, 1u8 as u32);
+  log(debug, 1u8 as u64);
+  log(debug, 1u8 as f32);
+  log(debug, 1u8 as f64);
+
+  log(debug, 1i16 as int);
+  log(debug, 1i16 as uint);
+  log(debug, 1i16 as float);
+  log(debug, 1i16 as bool);
+  log(debug, 1i16 as os::libc::FILE);
+  log(debug, 1i16 as i8);
+  log(debug, 1i16 as i16);
+  log(debug, 1i16 as i32);
+  log(debug, 1i16 as i64);
+  log(debug, 1i16 as u8);
+  log(debug, 1i16 as u16);
+  log(debug, 1i16 as u32);
+  log(debug, 1i16 as u64);
+  log(debug, 1i16 as f32);
+  log(debug, 1i16 as f64);
+
+  log(debug, 1u16 as int);
+  log(debug, 1u16 as uint);
+  log(debug, 1u16 as float);
+  log(debug, 1u16 as bool);
+  log(debug, 1u16 as os::libc::FILE);
+  log(debug, 1u16 as i8);
+  log(debug, 1u16 as i16);
+  log(debug, 1u16 as i32);
+  log(debug, 1u16 as i64);
+  log(debug, 1u16 as u8);
+  log(debug, 1u16 as u16);
+  log(debug, 1u16 as u32);
+  log(debug, 1u16 as u64);
+  log(debug, 1u16 as f32);
+  log(debug, 1u16 as f64);
+
+  log(debug, 1i32 as int);
+  log(debug, 1i32 as uint);
+  log(debug, 1i32 as float);
+  log(debug, 1i32 as bool);
+  log(debug, 1i32 as os::libc::FILE);
+  log(debug, 1i32 as i8);
+  log(debug, 1i32 as i16);
+  log(debug, 1i32 as i32);
+  log(debug, 1i32 as i64);
+  log(debug, 1i32 as u8);
+  log(debug, 1i32 as u16);
+  log(debug, 1i32 as u32);
+  log(debug, 1i32 as u64);
+  log(debug, 1i32 as f32);
+  log(debug, 1i32 as f64);
+
+  log(debug, 1u32 as int);
+  log(debug, 1u32 as uint);
+  log(debug, 1u32 as float);
+  log(debug, 1u32 as bool);
+  log(debug, 1u32 as os::libc::FILE);
+  log(debug, 1u32 as i8);
+  log(debug, 1u32 as i16);
+  log(debug, 1u32 as i32);
+  log(debug, 1u32 as i64);
+  log(debug, 1u32 as u8);
+  log(debug, 1u32 as u16);
+  log(debug, 1u32 as u32);
+  log(debug, 1u32 as u64);
+  log(debug, 1u32 as f32);
+  log(debug, 1u32 as f64);
+
+  log(debug, 1i64 as int);
+  log(debug, 1i64 as uint);
+  log(debug, 1i64 as float);
+  log(debug, 1i64 as bool);
+  log(debug, 1i64 as os::libc::FILE);
+  log(debug, 1i64 as i8);
+  log(debug, 1i64 as i16);
+  log(debug, 1i64 as i32);
+  log(debug, 1i64 as i64);
+  log(debug, 1i64 as u8);
+  log(debug, 1i64 as u16);
+  log(debug, 1i64 as u32);
+  log(debug, 1i64 as u64);
+  log(debug, 1i64 as f32);
+  log(debug, 1i64 as f64);
+
+  log(debug, 1u64 as int);
+  log(debug, 1u64 as uint);
+  log(debug, 1u64 as float);
+  log(debug, 1u64 as bool);
+  log(debug, 1u64 as os::libc::FILE);
+  log(debug, 1u64 as i8);
+  log(debug, 1u64 as i16);
+  log(debug, 1u64 as i32);
+  log(debug, 1u64 as i64);
+  log(debug, 1u64 as u8);
+  log(debug, 1u64 as u16);
+  log(debug, 1u64 as u32);
+  log(debug, 1u64 as u64);
+  log(debug, 1u64 as f32);
+  log(debug, 1u64 as f64);
+
+  log(debug, 1u64 as int);
+  log(debug, 1u64 as uint);
+  log(debug, 1u64 as float);
+  log(debug, 1u64 as bool);
+  log(debug, 1u64 as os::libc::FILE);
+  log(debug, 1u64 as i8);
+  log(debug, 1u64 as i16);
+  log(debug, 1u64 as i32);
+  log(debug, 1u64 as i64);
+  log(debug, 1u64 as u8);
+  log(debug, 1u64 as u16);
+  log(debug, 1u64 as u32);
+  log(debug, 1u64 as u64);
+  log(debug, 1u64 as f32);
+  log(debug, 1u64 as f64);
+
+  log(debug, true as int);
+  log(debug, true as uint);
+  log(debug, true as float);
+  log(debug, true as bool);
+  log(debug, true as os::libc::FILE);
+  log(debug, true as i8);
+  log(debug, true as i16);
+  log(debug, true as i32);
+  log(debug, true as i64);
+  log(debug, true as u8);
+  log(debug, true as u16);
+  log(debug, true as u32);
+  log(debug, true as u64);
+  log(debug, true as f32);
+  log(debug, true as f64);
+
+  log(debug, 1. as int);
+  log(debug, 1. as uint);
+  log(debug, 1. as float);
+  log(debug, 1. as bool);
+  log(debug, 1. as i8);
+  log(debug, 1. as i16);
+  log(debug, 1. as i32);
+  log(debug, 1. as i64);
+  log(debug, 1. as u8);
+  log(debug, 1. as u16);
+  log(debug, 1. as u32);
+  log(debug, 1. as u64);
+  log(debug, 1. as f32);
+  log(debug, 1. as f64);
+
+  log(debug, 1f32 as int);
+  log(debug, 1f32 as uint);
+  log(debug, 1f32 as float);
+  log(debug, 1f32 as bool);
+  log(debug, 1f32 as i8);
+  log(debug, 1f32 as i16);
+  log(debug, 1f32 as i32);
+  log(debug, 1f32 as i64);
+  log(debug, 1f32 as u8);
+  log(debug, 1f32 as u16);
+  log(debug, 1f32 as u32);
+  log(debug, 1f32 as u64);
+  log(debug, 1f32 as f32);
+  log(debug, 1f32 as f64);
+
+  log(debug, 1f64 as int);
+  log(debug, 1f64 as uint);
+  log(debug, 1f64 as float);
+  log(debug, 1f64 as bool);
+  log(debug, 1f64 as i8);
+  log(debug, 1f64 as i16);
+  log(debug, 1f64 as i32);
+  log(debug, 1f64 as i64);
+  log(debug, 1f64 as u8);
+  log(debug, 1f64 as u16);
+  log(debug, 1f64 as u32);
+  log(debug, 1f64 as u64);
+  log(debug, 1f64 as f32);
+  log(debug, 1f64 as f64);
 }

diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index fdcdfac1ee932e74566bd3682497806cec21745f..c5a26bcaad20b72be0260ef9b37b64ef35a22e80 100644 (file)
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -2,8 +2,8 @@
 import str;
 
 fn test(actual: str, expected: str) {
-    log_full(core::debug, actual);
-    log_full(core::debug, expected);
+    log(debug, actual);
+    log(debug, expected);
     assert (str::eq(actual, expected));
 }
 

diff --git a/src/test/run-pass/syntax-extension-shell.rs b/src/test/run-pass/syntax-extension-shell.rs
index 3153f60d2f31e4157c957fe5bd0e6715e8e40e5d..6ec80db8d55bfe1a3600d571c646a589d6dd5883 100644 (file)
--- a/src/test/run-pass/syntax-extension-shell.rs
+++ b/src/test/run-pass/syntax-extension-shell.rs
@@ -1,5 +1,5 @@
 // xfail-test
 fn main() {
   auto s = #shell { uname -a };
-  log_full(core::debug, s);
+  log(debug, s);
 }

diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs
index 901cc990864703d5f187261924896d65185d51b7..992fe0986ca433974c45367c236dbba0948ac044 100644 (file)
--- a/src/test/run-pass/tail-cps.rs
+++ b/src/test/run-pass/tail-cps.rs
@@ -8,12 +8,12 @@
 
 fn evenk(n: int, k: fn(bool) -> bool) -> bool {
     #debug("evenk");
-    log_full(core::debug, n);
+    log(debug, n);
     if n == 0 { be k(true); } else { be oddk(n - 1, k); }
 }
 
 fn oddk(n: int, k: fn(bool) -> bool) -> bool {
     #debug("oddk");
-    log_full(core::debug, n);
+    log(debug, n);
     if n == 0 { be k(false); } else { be 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 b512da1b204a72daaf6f3a80688cdd37d4d3a731..d54b31b07b512bcd751e4fe1337ed12bf2576f94 100644 (file)
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -8,7 +8,7 @@
 fn main() { test05(); }
 
 fn test05_start(ch : chan<int>) {
-    log_full(core::error, ch);
+    log(error, ch);
     send(ch, 10);
     #error("sent 10");
     send(ch, 20);
@@ -22,10 +22,10 @@ fn test05() {
     let ch = comm::chan(po);
     task::spawn(ch, test05_start);
     let value = comm::recv(po);
-    log_full(core::error, value);
+    log(error, value);
     value = comm::recv(po);
-    log_full(core::error, value);
+    log(error, value);
     value = comm::recv(po);
-    log_full(core::error, value);
+    log(error, value);
     assert (value == 30);
 }

diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index ee4a83385999bb7b32eb7901174bb72e1dd799f4..84e4825ec9be0f742b59bcb8c061edb1b86f039d 100644 (file)
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -10,10 +10,10 @@ fn start(c: comm::chan<comm::chan<str>>) {
     let b;
     a = comm::recv(p);
     assert a == "A";
-    log_full(core::error, a);
+    log(error, a);
     b = comm::recv(p);
     assert b == "B";
-    log_full(core::error, b);
+    log(error, b);
 }
 
 fn main() {

diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index 0381fabb2d3d4c80f4cacb01b19e5aded6540cf9..e37eb15ce39e74c16f0314bcf23e3e02ea741f10 100644 (file)
--- a/src/test/run-pass/task-comm-14.rs
+++ b/src/test/run-pass/task-comm-14.rs
@@ -8,7 +8,7 @@ fn main() {
     // Spawn 10 tasks each sending us back one int.
     let i = 10;
     while (i > 0) {
-        log_full(core::debug, i);
+        log(debug, i);
         task::spawn((i, comm::chan(po)), child);
         i = i - 1;
     }
@@ -19,7 +19,7 @@ fn main() {
     i = 10;
     let value = 0;
     while (i > 0) {
-        log_full(core::debug, i);
+        log(debug, i);
         value = comm::recv(po);
         i = i - 1;
     }
@@ -29,6 +29,6 @@ fn main() {
 
 fn child(&&args: (int, comm::chan<int>)) {
     let (x, ch) = args;
-    log_full(core::debug, x);
+    log(debug, x);
     comm::send(ch, x);
 }

diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 78b50e614fd06f554652906ea131c47616c655b5..407939c9e657100c9032ae8ff84daa53b291317b 100644 (file)
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -53,7 +53,7 @@ fn test00() {
     for t in tasks { task::join(t); }
 
     #debug("Completed: Final number is: ");
-    log_full(core::error, sum);
+    log(error, sum);
     // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
     //       number_of_messages));
     assert (sum == 480);

diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs
index 3409c8d4c54f0c2ba54e7de063a95d2f2f25c5c0..b27d0669c6143fd0099f54d5d49ead02698b328a 100644 (file)
--- a/src/test/run-pass/task-comm-4.rs
+++ b/src/test/run-pass/task-comm-4.rs
@@ -15,31 +15,31 @@ fn test00() {
     send(c, 4);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     send(c, 5);
     send(c, 6);
     send(c, 7);
     send(c, 8);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     r = comm::recv(p);
     sum += r;
-    log_full(core::debug, r);
+    log(debug, r);
     assert (sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
 }

diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index 77d86081c06628d666f90a683dc75b75e28d2afa..703fb3fc2a0112c8d27541de5bb37cd5abefffd9 100644 (file)
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -22,7 +22,7 @@ fn test00() {
     let i: int = 0;
     while i < number_of_messages {
         sum += comm::recv(p);
-        log_full(core::debug, r);
+        log(debug, r);
         i += 1;
     }
 

diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 7fbfe5e29164c38613b5ef666a94009e22f7adb4..85a9fb8dfbda4c57a1584d74f93796bb6a6d2226 100644 (file)
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -65,7 +65,7 @@ fn test01() {
     let p = port();
     #debug("Reading from a port that is never written to.");
     let value: int = recv(p);
-    log_full(core::debug, value);
+    log(debug, value);
 }
 
 fn test02() {
@@ -75,7 +75,7 @@ fn test02() {
     send(c, 42);
     #debug("Reading from a local task port.");
     let value: int = recv(p);
-    log_full(core::debug, value);
+    log(debug, value);
 }
 
 obj vector(mutable x: int, y: int) {
@@ -87,7 +87,7 @@ fn test03() {
     let v: vector = vector(1, 2);
     #debug("created object ...");
     let t: vector = v;
-    log_full(core::debug, v.length());
+    log(debug, v.length());
 }
 
 fn test04_start(&&_args: ()) {
@@ -120,7 +120,7 @@ fn test05() {
     value = recv(po);
     value = recv(po);
     value = recv(po);
-    log_full(core::debug, value);
+    log(debug, value);
 }
 
 fn test06_start(&&task_number: int) {

diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 417e537a90591bfed69ae6d27295f533f7185a50..2f09d1c6b4fd48930c8da4c9a455b06ab09b169d 100644 (file)
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -9,5 +9,5 @@ fn main() {
     #debug("main thread exiting");
 }
 
-fn child(&&x: int) { log_full(core::debug, x); }
+fn child(&&x: int) { log(debug, x); }
 

diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index cea3d49772e51e4a1fbd6916384cc0590cb1273d..487b440ee420f6a6982b9ae9b0b5025a3f00004d 100644 (file)
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -10,5 +10,5 @@ fn main() {
     let ch = chan(po);
     send(ch, 42);
     let r = recv(po);
-    log_full(core::error, r);
+    log(error, r);
 }

diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs
index 21159a32e73f494bbdc4ec265087d4a26c271f02..bcf3469281bf9f79ce5f2d39464bd874fda5fdc6 100644 (file)
--- a/src/test/run-pass/unique-in-tag.rs
+++ b/src/test/run-pass/unique-in-tag.rs
@@ -4,7 +4,7 @@ fn test1() {
     let x = u(~10);
     assert alt x {
       u(a) {
-        log_full(core::error, a);
+        log(error, a);
         *a
       }
       _ { 66 }

diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs
index 4b545eb9c7940a9193d2601ce9b8354f29a534f5..ef74e70eede759b6c9357b521f52c51a348bcca0 100644 (file)
--- a/src/test/run-pass/unique-log.rs
+++ b/src/test/run-pass/unique-log.rs
@@ -1,4 +1,4 @@
 fn main() {
     let i = ~100;
-    log_full(core::error, i);
+    log(error, i);
 }
\ No newline at end of file

diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs
index d6908607130e2f30ba1d7273434a6b1a57f2b7e0..a8ca302b3952638ce29645f6d8e60d15d6c6be85 100644 (file)
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -4,7 +4,7 @@
 fn main() {
     assert alt u(~10) {
       u(a) {
-        log_full(core::error, a);
+        log(error, a);
         *a
       }
       _ { 66 }

diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs
index 52181a0cf5a0fc39f166203b7393bc5dd3dd568a..2ccf2394beda6849fc9ba0323ab04d9b00ef720b 100644 (file)
--- a/src/test/run-pass/unreachable-code.rs
+++ b/src/test/run-pass/unreachable-code.rs
@@ -19,13 +19,13 @@ fn call_id_4() { while id(break) { } }
 
 fn fail_fail() { fail fail; }
 
-fn log_fail() { log_full(core::error, fail); }
+fn log_fail() { log(error, fail); }
 
-fn log_ret() { log_full(core::error, ret); }
+fn log_ret() { log(error, ret); }
 
-fn log_break() { while true { log_full(core::error, break); } }
+fn log_break() { while true { log(error, break); } }
 
-fn log_cont() { do { log_full(core::error, cont); } while false }
+fn log_cont() { do { log(error, cont); } while false }
 
 fn ret_ret() -> int { ret (ret 2) + 3; }
 

diff --git a/src/test/run-pass/use-uninit-alt.rs b/src/test/run-pass/use-uninit-alt.rs
index d30f7d65afb30a807c6de58def3d718bf435c12a..5e77cf8f684677fc58c06c308fa27951adc8ef2a 100644 (file)
--- a/src/test/run-pass/use-uninit-alt.rs
+++ b/src/test/run-pass/use-uninit-alt.rs
@@ -8,4 +8,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 tag myoption<T> { none; some(T); }
 
-fn main() { log_full(core::debug, 5); }
+fn main() { log(debug, 5); }

diff --git a/src/test/run-pass/use-uninit-alt2.rs b/src/test/run-pass/use-uninit-alt2.rs
index 4481d65e9f48c6307c15e02d4d91954ae84b3969..cd54239ec563572ea699d934032bc0d4a0c959d4 100644 (file)
--- a/src/test/run-pass/use-uninit-alt2.rs
+++ b/src/test/run-pass/use-uninit-alt2.rs
@@ -8,4 +8,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 tag myoption<T> { none; some(T); }
 
-fn main() { log_full(core::debug, 5); }
+fn main() { log(debug, 5); }

diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index ddca218ada2d06814b11ace8ff2762f264b7c8af..7dd73a14342342293a686110cb31e028f9546332 100644 (file)
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -8,8 +8,8 @@
 fn main() {
   auto s = str.alloc(10 as uint);
   s += "hello ";
-  log_full(core::debug, s);
+  log(debug, s);
   s += "there";
-  log_full(core::debug, s);
+  log(debug, s);
   auto z = vec.alloc::<int>(10 as uint);
 }

diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
index 778fa22c446a0d44942c4b17aade414434322bb2..b2288162bd6bfb3387d8c3b368014c127eaad011 100644 (file)
--- a/src/test/run-pass/utf8.rs
+++ b/src/test/run-pass/utf8.rs
@@ -32,10 +32,10 @@ fn main() {
     fn check_str_eq(a: str, b: str) {
         let i: int = 0;
         for ab: u8 in a {
-            log_full(core::debug, i);
-            log_full(core::debug, ab);
+            log(debug, i);
+            log(debug, ab);
             let bb: u8 = b[i];
-            log_full(core::debug, bb);
+            log(debug, bb);
             assert (ab == bb);
             i += 1;
         }

diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 7604f74f7b20d1b2d08da3995207b642306936f1..08a81ba6e92b9115d042ab44fc259733ab081386 100644 (file)
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -6,7 +6,7 @@ fn main() {
     let a: [int] = [1, 2, 3, 4, 5];
     let b: [int] = [6, 7, 8, 9, 0];
     let v: [int] = a + b;
-    log_full(core::debug, v[9]);
+    log(debug, v[9]);
     assert (v[0] == 1);
     assert (v[7] == 8);
     assert (v[9] == 0);

diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs
index c41293dadb68380a4785889a1336d26be6a48ce6..7b27feab6f460178f0965381307a018fde499153 100644 (file)
--- a/src/test/run-pass/vec-late-init.rs
+++ b/src/test/run-pass/vec-late-init.rs
@@ -3,5 +3,5 @@
 fn main() {
     let later: [int];
     if true { later = [1]; } else { later = [2]; }
-    log_full(core::debug, later[0]);
+    log(debug, later[0]);
 }

diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index ad88a315ab2d22661b5bba49f38e5299a9567b6d..e8a39b2a0553cedb8da9f191c0c3f495018d2482 100644 (file)
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -38,7 +38,7 @@ fn test_loop() {
     let i = 20;
     let expected_len = 1u;
     while i > 0 {
-        log_full(core::error, vec::len(a));
+        log(error, vec::len(a));
         assert (vec::len(a) == expected_len);
         a += a;
         i -= 1;

diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 3870ebdc63e075755695dec4b7cdb6ee5951a41b..6b110e9e275a62038df0209842048040baae12dc 100644 (file)
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -36,14 +36,14 @@ fn notsure() {
 }
 
 fn hammertime() -> int {
-    let _x = log_full(core::debug, true == (ret 0));
+    let _x = log(debug, true == (ret 0));
 }
 
 fn canttouchthis() -> uint {
     pure fn p() -> bool { true }
     let _a = (assert (true)) == (check (p()));
     let _c = (check (p())) == ();
-    let _b = (log_full(core::debug, 0) == (ret 0u));
+    let _b = (log(debug, 0) == (ret 0u));
 }
 
 fn angrydome() {

diff --git a/src/test/run-pass/while-and-do-while.rs b/src/test/run-pass/while-and-do-while.rs
index da7101349a3df1326baa35f91fc4bd915abe84f9..336633623be4273e519370497dbbbd1786458f5c 100644 (file)
--- a/src/test/run-pass/while-and-do-while.rs
+++ b/src/test/run-pass/while-and-do-while.rs
@@ -3,10 +3,10 @@
 fn main() {
     let x: int = 10;
     let y: int = 0;
-    while y < x { log_full(core::debug, y); #debug("hello"); y = y + 1; }
+    while y < x { log(debug, y); #debug("hello"); y = y + 1; }
     do {
         #debug("goodbye");
         x = x - 1;
-        log_full(core::debug, x);
+        log(debug, x);
     } while x > 0
 }

diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs
index 06d7a1492f0708a9b0d6f856cec9547e833eebf3..9054d765e04739cccfa3af11359f2a2efff184fb 100644 (file)
--- a/src/test/run-pass/while-cont.rs
+++ b/src/test/run-pass/while-cont.rs
@@ -3,7 +3,7 @@ fn main() {
     let i = 1;
     while i > 0 {
         assert (i > 0);
-        log_full(core::debug, i);
+        log(debug, i);
         i -= 1;
         cont;
     }

diff --git a/src/test/run-pass/while-loop-constraints-2.rs b/src/test/run-pass/while-loop-constraints-2.rs
index 65759d537a93eed6ffc84cfea9843c5d74dd8338..4f207a431545d1b02aea735966bc8e24d58c0e8b 100644 (file)
--- a/src/test/run-pass/while-loop-constraints-2.rs
+++ b/src/test/run-pass/while-loop-constraints-2.rs
@@ -6,7 +6,7 @@ fn main() {
     while z < 50 {
         z += 1;
         while false { x <- y; y = z; }
-        log_full(core::debug, y);
+        log(debug, y);
     }
     assert (y == 42 && z == 50);
 }

diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs
index 6f73e9780f9f85ace4b9e393b2557f49ac2bdcb1..2fe5f8b432b1e9525bc925d3a74f5807adb95a08 100644 (file)
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -5,7 +5,7 @@
 fn main() {
     let i: int = 90;
     while i < 100 {
-        log_full(core::debug, i);
+        log(debug, i);
         i = i + 1;
         if i == 95 {
             let v: [int] =

diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs
index fc4faf4600836bb29065a164ad6b2633ea290d59..765f87de7b290d0ff0289d216e9fe71c7ad70f35 100644 (file)
--- a/src/test/run-pass/x86stdcall.rs
+++ b/src/test/run-pass/x86stdcall.rs
@@ -13,7 +13,7 @@ fn main() {
     let expected = 1234u;
     kernel32::SetLastError(expected);
     let actual = kernel32::GetLastError();
-    log_full(core::error, actual);
+    log(error, actual);
     assert (expected == actual);
 }
 

diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs
index ea7c39166624f4146a6c82e30068c775d91a7518..ba5145870e1764d6c87a8d2959037cc043f38065 100644 (file)
--- a/src/test/run-pass/yield2.rs
+++ b/src/test/run-pass/yield2.rs
@@ -3,5 +3,5 @@
 
 fn main() {
     let i: int = 0;
-    while i < 100 { i = i + 1; log_full(core::error, i); task::yield(); }
+    while i < 100 { i = i + 1; log(error, i); task::yield(); }
 }

diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index f48260f4ccefa825bd18980f871eb57154e152d2..a94b1739b32454a8098d8ea1819490fa896c4d76 100644 (file)
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -14,21 +14,21 @@ fn test_simple() {
     assert (d.size() == 3u);
     d.add_back(137);
     assert (d.size() == 4u);
-    log_full(core::debug, d.peek_front());
+    log(debug, d.peek_front());
     assert (d.peek_front() == 42);
-    log_full(core::debug, d.peek_back());
+    log(debug, d.peek_back());
     assert (d.peek_back() == 137);
     let i: int = d.pop_front();
-    log_full(core::debug, i);
+    log(debug, i);
     assert (i == 42);
     i = d.pop_back();
-    log_full(core::debug, i);
+    log(debug, i);
     assert (i == 137);
     i = d.pop_back();
-    log_full(core::debug, i);
+    log(debug, i);
     assert (i == 137);
     i = d.pop_back();
-    log_full(core::debug, i);
+    log(debug, i);
     assert (i == 17);
     assert (d.size() == 0u);
     d.add_back(3);
@@ -39,10 +39,10 @@ fn test_simple() {
     assert (d.size() == 3u);
     d.add_front(1);
     assert (d.size() == 4u);
-    log_full(core::debug, d.get(0));
-    log_full(core::debug, d.get(1));
-    log_full(core::debug, d.get(2));
-    log_full(core::debug, d.get(3));
+    log(debug, d.get(0));
+    log(debug, d.get(1));
+    log(debug, d.get(2));
+    log(debug, d.get(3));
     assert (d.get(0) == 1);
     assert (d.get(1) == 2);
     assert (d.get(2) == 3);

diff --git a/src/test/stdtest/four.rs b/src/test/stdtest/four.rs
index f28edd03e36c2202c1c62d95543fd8639c2c7b40..0810253c9fd48203d42b9c4b5ff9b35286564730 100644 (file)
--- a/src/test/stdtest/four.rs
+++ b/src/test/stdtest/four.rs
@@ -139,7 +139,7 @@ fn test_four_to_tri() {
     assert tri::eq( four::to_trit(four::true), tri::true );
     assert tri::eq( four::to_trit(four::false), tri::false );
     assert tri::eq( four::to_trit(four::none), tri::unknown );
-    log_full(core::debug, four::to_trit(four::both));
+    log(debug, four::to_trit(four::both));
     assert tri::eq( four::to_trit(four::both), tri::unknown );
 }
 

diff --git a/src/test/stdtest/fs.rs b/src/test/stdtest/fs.rs
index fca25f70fa553355bcf4762ff1a3c742a259d392..a0ab02a898f26e57c804c7076b98135e1d2676eb 100644 (file)
--- a/src/test/stdtest/fs.rs
+++ b/src/test/stdtest/fs.rs
@@ -7,7 +7,7 @@
 #[test]
 fn test_connect() {
     let slash = fs::path_sep();
-    log_full(core::error, fs::connect("a", "b"));
+    log(error, fs::connect("a", "b"));
     assert (fs::connect("a", "b") == "a" + slash + "b");
     assert (fs::connect("a" + slash, "b") == "a" + slash + "b");
 }
@@ -22,7 +22,7 @@ fn list_dir() {
     // Just assuming that we've got some contents in the current directory
     assert (vec::len(dirs) > 0u);
 
-    for dir in dirs { log_full(core::debug, dir); }
+    for dir in dirs { log(debug, dir); }
 }
 
 #[test]
@@ -140,7 +140,7 @@ fn normalize9() {
 fn normalize10() {
     let actual = fs::normalize("/a/b/c/../d/./../../e/");
     let expected = "/a/e/";
-    log_full(core::error, actual);
+    log(error, actual);
     assert actual == expected;
 }
 
@@ -156,7 +156,7 @@ fn normalize11() {
 fn normalize12() {
    let actual = fs::normalize("C:/whatever");
    let expected = "C:/whatever";
-   log_full(core::error, actual);
+   log(error, actual);
    assert actual == expected;
 }
 

diff --git a/src/test/stdtest/getopts.rs b/src/test/stdtest/getopts.rs
index 5d397f6e70241e13bcb54a04ba7d3574d759d128..52b68f888c48c3ac6ab601464d44bb8f547be786 100644 (file)
--- a/src/test/stdtest/getopts.rs
+++ b/src/test/stdtest/getopts.rs
@@ -246,7 +246,7 @@ fn test_optflag_long_arg() {
     let rs = opt::getopts(args, opts);
     alt rs {
       err(f) {
-        log_full(core::error, opt::fail_str(f));
+        log(error, opt::fail_str(f));
         check_fail_type(f, unexpected_argument);
       }
       _ { fail; }

diff --git a/src/test/stdtest/io.rs b/src/test/stdtest/io.rs
index 742ec39d8283efa64b4afc069c80ac1d2301e411..7e481fabea029a5bba413fbed05dd3b9a1bc7d6c 100644 (file)
--- a/src/test/stdtest/io.rs
+++ b/src/test/stdtest/io.rs
@@ -9,9 +9,9 @@
 #[test]
 fn test_simple() {
     let tmpfile: str = "tmp/lib-io-test-simple.tmp";
-    log_full(core::debug, tmpfile);
+    log(debug, tmpfile);
     let frood: str = "A hoopy frood who really knows where his towel is.";
-    log_full(core::debug, frood);
+    log(debug, frood);
     {
         let out: io::writer =
             result::get(io::file_writer(tmpfile, [io::create, io::truncate]));
@@ -19,7 +19,7 @@ fn test_simple() {
     }
     let inp: io::reader = result::get(io::file_reader(tmpfile));
     let frood2: str = inp.read_c_str();
-    log_full(core::debug, frood2);
+    log(debug, frood2);
     assert (str::eq(frood, frood2));
 }
 

diff --git a/src/test/stdtest/os.rs b/src/test/stdtest/os.rs
index 2d1a64da7539952e6bb07c4c214fa3442840a233..7f7b2c4f3b392f9f95195169515cc47fccce0af4 100644 (file)
--- a/src/test/stdtest/os.rs
+++ b/src/test/stdtest/os.rs
@@ -36,7 +36,7 @@ fn get_exe_path() {
     let path = std::os::get_exe_path();
     assert option::is_some(path);
     let path = option::get(path);
-    log_full(core::debug, path);
+    log(debug, path);
 
     // Hard to test this function
     if std::os::target_os() != "win32" {

diff --git a/src/test/stdtest/path.rs b/src/test/stdtest/path.rs
index bb07fae689937d5561b4f1f1f17b4eb423ed3897..e711288c6152c616fdbf1b62f20e16263844865c 100644 (file)
--- a/src/test/stdtest/path.rs
+++ b/src/test/stdtest/path.rs
@@ -11,8 +11,8 @@
 fn test() {
     assert (!fs::path_is_absolute("test-path"));
 
-    log_full(core::debug, "Current working directory: " + os::getcwd());
+    log(debug, "Current working directory: " + os::getcwd());
 
-    log_full(core::debug, fs::make_absolute("test-path"));
-    log_full(core::debug, fs::make_absolute("/usr/bin"));
+    log(debug, fs::make_absolute("test-path"));
+    log(debug, fs::make_absolute("/usr/bin"));
 }

diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index cac57233ea149beced56327518f021607d6f4a08..67e16942e41111a047ac800274c30f070bc53761 100644 (file)
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -13,7 +13,7 @@ fn check_sort(v1: [mutable int], v2: [mutable int]) {
     std::sort::quick_sort::<int>(f, v1);
     let i = 0u;
     while i < len {
-        log_full(core::debug, v2[i]);
+        log(debug, v2[i]);
         assert (v2[i] == v1[i]);
         i += 1u;
     }

diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 50f7bd27427b91fb0a84fd1f3ad8990fe51edc04..b4371b2c3b45b37171a3f6b75c372386d280e013 100644 (file)
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -11,7 +11,7 @@ fn check_sort(v1: [mutable int], v2: [mutable int]) {
     std::sort::quick_sort3::<int>(f1, f2, v1);
     let i = 0u;
     while i < len {
-        log_full(core::debug, v2[i]);
+        log(debug, v2[i]);
         assert (v2[i] == v1[i]);
         i += 1u;
     }

diff --git a/src/test/stdtest/rand.rs b/src/test/stdtest/rand.rs
index e59134830d286cc1e0f2422bce3e98e373f17878..1460fb87f808f4524b31f9c78f867116555cc7a0 100644 (file)
--- a/src/test/stdtest/rand.rs
+++ b/src/test/stdtest/rand.rs
@@ -8,33 +8,33 @@
 #[test]
 fn test() {
     let r1: rand::rng = rand::mk_rng();
-    log_full(core::debug, r1.next());
-    log_full(core::debug, r1.next());
+    log(debug, r1.next());
+    log(debug, r1.next());
     {
         let r2 = rand::mk_rng();
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r2.next());
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r2.next());
-        log_full(core::debug, r2.next());
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r1.next());
-        log_full(core::debug, r2.next());
-        log_full(core::debug, r2.next());
-        log_full(core::debug, r2.next());
+        log(debug, r1.next());
+        log(debug, r2.next());
+        log(debug, r1.next());
+        log(debug, r1.next());
+        log(debug, r2.next());
+        log(debug, r2.next());
+        log(debug, r1.next());
+        log(debug, r1.next());
+        log(debug, r1.next());
+        log(debug, r2.next());
+        log(debug, r2.next());
+        log(debug, r2.next());
     }
-    log_full(core::debug, r1.next());
-    log_full(core::debug, r1.next());
+    log(debug, r1.next());
+    log(debug, r1.next());
 }
 
 #[test]
 fn genstr() {
     let r: rand::rng = rand::mk_rng();
-    log_full(core::debug, r.gen_str(10u));
-    log_full(core::debug, r.gen_str(10u));
-    log_full(core::debug, r.gen_str(10u));
+    log(debug, r.gen_str(10u));
+    log(debug, r.gen_str(10u));
+    log(debug, r.gen_str(10u));
     assert(str::char_len(r.gen_str(10u)) == 10u);
     assert(str::char_len(r.gen_str(16u)) == 16u);
 }

diff --git a/src/test/stdtest/run.rs b/src/test/stdtest/run.rs
index e0d68d21756a849fb9b179b938804ca2e829f03b..fae791c3d9cfaae33376f298982893cee99e9a4f 100644 (file)
--- a/src/test/stdtest/run.rs
+++ b/src/test/stdtest/run.rs
@@ -35,8 +35,8 @@ fn test_pipes() {
     readclose(pipe_err.in);
     os::waitpid(pid);
 
-    log_full(core::debug, expected);
-    log_full(core::debug, actual);
+    log(debug, expected);
+    log(debug, actual);
     assert (expected == actual);
 
     fn writeclose(fd: fd_t, s: str) {

diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index 9a8f4686920430a69fa18587dbe8a9daa197ac51..83d885797bfc1ce11c96b681505d3579f74e9a0b 100644 (file)
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -9,7 +9,7 @@ fn check_sort(v1: [int], v2: [int]) {
     let v3 = std::sort::merge_sort::<int>(f, v1);
     let i = 0u;
     while i < len {
-        log_full(core::debug, v3[i]);
+        log(debug, v3[i]);
         assert (v3[i] == v2[i]);
         i += 1u;
     }

diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index 0e819bac4c861e138cb7045a4525bff9c658e578..c3f0e53bac59aef29a463bf35a6130d8f4e29f93 100644 (file)
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -42,10 +42,10 @@ fn test_index_and_rindex() {
 #[test]
 fn test_split() {
     fn t(s: str, c: char, u: [str]) {
-        log_full(core::debug, "split: " + s);
+        log(debug, "split: " + s);
         let v = str::split(s, c as u8);
         #debug("split to: ");
-        log_full(core::debug, v);
+        log(debug, v);
         assert (vec::all2(v, u, { |a,b| a == b }));
     }
     t("abc.hello.there", '.', ["abc", "hello", "there"]);
@@ -56,12 +56,12 @@ fn t(s: str, c: char, u: [str]) {
 #[test]
 fn test_splitn() {
     fn t(s: str, c: char, n: uint, u: [str]) {
-        log_full(core::debug, "splitn: " + s);
+        log(debug, "splitn: " + s);
         let v = str::splitn(s, c as u8, n);
         #debug("split to: ");
-        log_full(core::debug, v);
+        log(debug, v);
         #debug("comparing vs. ");
-        log_full(core::debug, u);
+        log(debug, u);
         assert (vec::all2(v, u, { |a,b| a == b }));
     }
     t("abc.hello.there", '.', 0u, ["abc.hello.there"]);
@@ -92,8 +92,8 @@ fn t(s: str, sep: str, i: int, k: str) {
 fn test_find() {
     fn t(haystack: str, needle: str, i: int) {
         let j: int = str::find(haystack, needle);
-        log_full(core::debug, "searched for " + needle);
-        log_full(core::debug, j);
+        log(debug, "searched for " + needle);
+        log(debug, j);
         assert (i == j);
     }
     t("this is a simple", "is a", 5);
@@ -329,8 +329,8 @@ fn vec_str_conversions() {
     while i < n1 {
         let a: u8 = s1[i];
         let b: u8 = s2[i];
-        log_full(core::debug, a);
-        log_full(core::debug, b);
+        log(debug, a);
+        log(debug, b);
         assert (a == b);
         i += 1u;
     }

diff --git a/src/test/stdtest/sys.rs b/src/test/stdtest/sys.rs
index 8a47d9c3039d110eb5bc3ba938ab36ea751a2da3..632f42c0f6be1abb03240bcd2155d3737561b33d 100644 (file)
--- a/src/test/stdtest/sys.rs
+++ b/src/test/stdtest/sys.rs
@@ -4,7 +4,7 @@
 
 #[test]
 fn last_os_error() {
-    log_full(core::debug, sys::last_os_error());
+    log(debug, sys::last_os_error());
 }
 
 #[test]

diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index 1059f9084e3e3e50d813c34f119ea7597f6395cd..31299e703be3589be5212a07a5ba2fa952ab741d 100644 (file)
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -35,7 +35,7 @@ fn winner(&&_i: ()) { }
     task::spawn_notify((), winner, comm::chan(p));
     let s = comm::recv(p);
     #error("received task status message");
-    log_full(core::error, s);
+    log(error, s);
     alt s {
       task::exit(_, task::tr_success.) {/* yay! */ }
       _ { fail "invalid task status received" }
@@ -52,7 +52,7 @@ fn test_join_chan_fail() {
     task::spawn_notify((), failer, comm::chan(p));
     let s = comm::recv(p);
     #error("received task status message");
-    log_full(core::error, s);
+    log(error, s);
     alt s {
       task::exit(_, task::tr_failure.) {/* yay! */ }
       _ { fail "invalid task status received" }
@@ -70,7 +70,7 @@ fn winner(&&_i: ()) { }
 #[ignore]
 fn spawn_polymorphic() {
     // FIXME #1038: Can't spawn palymorphic functions
-    /*fn foo<send T>(x: T) { log_full(core::error, x); }
+    /*fn foo<send T>(x: T) { log(error, x); }
 
     task::spawn(true, foo);
     task::spawn(42, foo);*/