diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 3c56cdd9f61..f3eaacb2ba3 100644
--- 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 e7359fb2cdf..98917342c2d 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -596,7 +596,7 @@ fn link_binary(sess: session::session,
         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 56a38ec14b4..b19b33c79db 100644
--- 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 1ad7d743b63..b97b9a65510 100644
--- 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 71fabffe9bc..51858e2b8b7 100644
--- 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 2b6fe006a2a..393c7000bce 100644
--- 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 2cd126be54d..5df9f3fed8b 100644
--- 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 021917f3d3e..40c13d64b4a 100644
--- 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 2cf7549da49..65988ef917e 100644
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -15,12 +15,12 @@ fn collect_ids_block(b: blk, rs: @mutable [node_id]) { *rs += [b.node.id]; }
 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 2269469648a..baba4faa463 100644
--- 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 args_mention<T>(args: [@constr_arg_use], q: fn([T], node_id) -> bool,
         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 ce6be98b124..0b2f9a3e9a5 100644
--- 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 c5756b7f996..b853643362b 100644
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -13,7 +13,7 @@ type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt};
 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 6ac6daaa3fc..83acaaa5902 100644
--- 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 e1f802954d1..492570e9123 100644
--- 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 b91c19644bb..0530b743eef 100644
--- 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 pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr])
     }
     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 pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr])
             }
         }
         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 9821f7bdfa9..338c29ddb07 100644
--- 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 209d56a51d0..3f2c11dd821 100644
--- 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_bottom_expr(p: parser) -> @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 e113817788b..02e34ccee88 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -413,7 +413,7 @@ obj printer(out: io::writer,
     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 976fa3f1b96..ac032ffa76a 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -916,7 +916,7 @@ fn print_expr(s: ps, &&expr: @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 0a1bcc8a9f1..03a6136656a 100644
--- 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 651bef07109..6ffe1bda6b8 100644
--- 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 4b37dede936..91cb090b83c 100644
--- 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 84ea81f9fce..29ab66872ce 100644
--- 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 1dc1df2a7a3..de5f9e66f28 100644
--- 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 3b31832a9b7..6cb3ada6a88 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -287,7 +287,7 @@ Example:
 > 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 05f953861f7..503a336f7cd 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -22,7 +22,7 @@ Tasks may execute in parallel and are scheduled automatically by the runtime.
 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 9719b8578e3..deb31f59ba0 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -292,7 +292,7 @@ obj fd_buf_writer(fd: fd_t, res: option::t<@fd_res>) {
             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 e532681c8db..543b3f5109d 100644
--- 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 aec0422f5bf..eaab9d6b731 100644
--- 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 51439a8bd97..6d8a17cc932 100644
--- 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 1e4283443b9..c833cc92f80 100644
--- a/src/test/bench/shootout-fannkuchredux.rs
+++ b/src/test/bench/shootout-fannkuchredux.rs
@@ -43,7 +43,7 @@ fn fannkuch(n: int) -> int {
 
         let 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 97bec11f43f..a47c0548a27 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -44,31 +44,31 @@ fn select_random(r: u32, genelist: [aminoacids]) -> 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 b9624ecb9e6..afb1b4a9289 100644
--- 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 72c98a4c3be..136d1057d20 100644
--- 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 5c008c49019..3ba6a6f7e2e 100644
--- 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 dcab0e8bde5..cf8986aa0f7 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -88,7 +88,7 @@ mod map_reduce {
                 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 @@ mod map_reduce {
               }
               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 a05ce493ddf..26d40d9c731 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -78,7 +78,7 @@ mod map_reduce {
 
     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 @@ mod map_reduce {
               }
               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 a950cc117e3..0845b33eacf 100644
--- a/src/test/compile-fail/alt-join.rs
+++ b/src/test/compile-fail/alt-join.rs
@@ -7,6 +7,6 @@ fn my_fail() -> ! { fail; }
 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 6b966f4964d..b0b4c0da5e3 100644
--- 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 eeeae1793b7..764cb7bdb41 100644
--- 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 16c83c56a9e..112066d1dea 100644
--- 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 375eadac779..8fb6a9e8737 100644
--- 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 0ef523e753d..c849c17a9cb 100644
--- 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 340a38e4993..0246580db1a 100644
--- 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 420aaa280c2..9c50d29fa4e 100644
--- 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 4b2e2c74ffd..673a22ce11a 100644
--- 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 ad9e147deeb..d70d935f602 100644
--- 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 273f93bac22..da6cfb652b5 100644
--- 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 1a41ece08c0..2985d98a34a 100644
--- a/src/test/compile-fail/block-coerce-no.rs
+++ b/src/test/compile-fail/block-coerce-no.rs
@@ -12,5 +12,5 @@ fn coerce(b: block()) -> fn() {
 
 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 7afefb0f36f..63a2e9bcb39 100644
--- 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 1bff806ab46..dc14053084d 100644
--- 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 68870a1b876..4d7f73b341c 100644
--- 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 a7a6a92fd7c..b5e8d2a909f 100644
--- 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 3547f565451..262e536b445 100644
--- 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 912a7f27dcc..bed10a12de5 100644
--- 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 546dbbd411d..c37ccd29f0d 100644
--- 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 68334f0fda0..bc7ec4491ee 100644
--- 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 f7f530dc90a..3d9ec1dfad3 100644
--- 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 479908a8d3c..20bd01fb2ac 100644
--- 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 8bf03564393..b044d56944b 100644
--- 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 13163fa32f2..bda344587d9 100644
--- 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 e5fac40b8fb..aadbecc40a7 100644
--- a/src/test/compile-fail/fn-constraint.rs
+++ b/src/test/compile-fail/fn-constraint.rs
@@ -5,5 +5,5 @@ import str::*;
 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 9c998682fc3..5eb7541a520 100644
--- 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 5f2e6db0e8b..8e35bc341b1 100644
--- 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 69dedb57955..cd6ebeb126b 100644
--- a/src/test/compile-fail/if-check-precond-fail.rs
+++ b/src/test/compile-fail/if-check-precond-fail.rs
@@ -5,7 +5,7 @@ pure fn even(x: uint) -> bool {
     } 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 6c560ffb41d..0ff469a871c 100644
--- 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 8b5da1c196a..0a733687aa3 100644
--- a/src/test/compile-fail/lambda-mutate-nested.rs
+++ b/src/test/compile-fail/lambda-mutate-nested.rs
@@ -6,10 +6,10 @@ fn f2(x: block()) { x(); }
 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 c5b90f9edde..6ba1cfc5401 100644
--- 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 fd5566e5c32..711e9a7095c 100644
--- 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 8cae7c2fc36..2a03395f1c1 100644
--- 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 95de145e52e..4347044d2a3 100644
--- a/src/test/compile-fail/nonscalar-cast.rs
+++ b/src/test/compile-fail/nonscalar-cast.rs
@@ -4,5 +4,5 @@ use std;
 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 527644907f0..08b261a2ccd 100644
--- 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 54ab6c3c1b7..778a9d8cb7b 100644
--- 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 c189c97ded9..005a29cc435 100644
--- 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 3484a14f084..8190b74efc7 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -10,7 +10,7 @@ tag bar { t1((), option::t<[int]>); t2; }
 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 a7c7d06cb5f..9244b4b73b3 100644
--- 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 523641698d3..fad12e24a7c 100644
--- 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 ff6a197abf8..6cdaafb22a5 100644
--- 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 a21523d0763..403e0bb07cb 100644
--- 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 4cc76c93a17..3456a4f6a1a 100644
--- 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 4cf50b119f8..97e4515d98d 100644
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -6,5 +6,5 @@ resource r(b: bool) {
 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 9fa456aaacb..fdc9072fd93 100644
--- 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 94b95e190bd..ec1e5c01ffb 100644
--- a/src/test/compile-fail/unsafe-alias-2.rs
+++ b/src/test/compile-fail/unsafe-alias-2.rs
@@ -4,5 +4,5 @@ fn whoknows(x: @mutable {mutable x: int}) { x.x = 10; }
 
 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 2b71a5e72d8..905a6a922f1 100644
--- 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 e19edcfddc7..56adb4411ba 100644
--- a/src/test/compile-fail/unsafe-alt.rs
+++ b/src/test/compile-fail/unsafe-alt.rs
@@ -4,5 +4,5 @@ tag foo { left({mutable x: int}); right(bool); }
 
 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 caaab6d8977..05bad8ee833 100644
--- 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 f740d7d7592..3ab7fe974a5 100644
--- 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 26decd8baeb..6beb247e931 100644
--- a/src/test/compile-fail/unsupported-cast.rs
+++ b/src/test/compile-fail/unsupported-cast.rs
@@ -4,5 +4,5 @@ use std;
 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 e0a06d73acc..d4d42b55538 100644
--- 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 dfd34aa1168..7dc3f7b4a32 100644
--- 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 abbca6008fc..be949453699 100644
--- 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 e731ba4f083..b824567133a 100644
--- 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 5fac7d3ee6b..5c3c9a3cda7 100644
--- 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 c376441163d..df697c8af67 100644
--- 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 d2fb07bd1f7..ce1aae2fa8a 100644
--- 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 15cb4ab9902..287ee2d684c 100644
--- 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 6ea21de7f58..aa31a3857dc 100644
--- 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 2203adbd7a7..adef5da4d0e 100644
--- a/src/test/run-fail/binop-fail-2.rs
+++ b/src/test/run-fail/binop-fail-2.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_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 d8aefe7d6df..83368cd1a07 100644
--- a/src/test/run-fail/binop-fail.rs
+++ b/src/test/run-fail/binop-fail.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_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 bdb8ecc9453..a5d14f14303 100644
--- a/src/test/run-fail/fail-arg.rs
+++ b/src/test/run-fail/fail-arg.rs
@@ -1,4 +1,4 @@
 // error-pattern:woe
-fn f(a: int) { log_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 6f466ea1f64..40e259a0446 100644
--- 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 0bf23e4a93c..31e95d5c385 100644
--- a/src/test/run-fail/if-check-fail.rs
+++ b/src/test/run-fail/if-check-fail.rs
@@ -7,7 +7,7 @@ pure fn even(x: uint) -> bool {
 
 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 a9877ab4b7a..71b7323240d 100644
--- a/src/test/run-fail/if-cond-bot.rs
+++ b/src/test/run-fail/if-cond-bot.rs
@@ -1,3 +1,3 @@
 // error-pattern:quux
-fn my_err(s: str) -> ! { log_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 314483ca534..ca9e0482519 100644
--- 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 8d8a6517a7d..d6af174757c 100644
--- 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 f25c78b03e4..462e6acda4e 100644
--- a/src/test/run-pass/alt-tag.rs
+++ b/src/test/run-pass/alt-tag.rs
@@ -11,9 +11,9 @@ tag color {
 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 c4b544c7c68..7ed3bc4505d 100644
--- a/src/test/run-pass/argv.rs
+++ b/src/test/run-pass/argv.rs
@@ -1,5 +1,5 @@
 fn main(args: [str]) {
     let vs: [str] = ["hi", "there", "this", "is", "a", "vec"];
     let vvs: [[str]] = [args, vs];
-    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 1649900305a..d86349346bd 100644
--- 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 d1c6ac117a3..f815c2e4801 100644
--- 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 5c963b6cc51..ed8c71aecba 100644
--- 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 6affd11366e..efeb8b88b15 100644
--- 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 6a0c1ea4633..e12caefe140 100644
--- 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 cbf936429a3..9c2ff78248c 100644
--- 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 71bd75d03b6..85bb68e7387 100644
--- a/src/test/run-pass/block-explicit-types.rs
+++ b/src/test/run-pass/block-explicit-types.rs
@@ -1,4 +1,4 @@
 fn main() {
     fn as_buf<T>(s: str, f: 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 2a2f754ca86..0f09aae2409 100644
--- 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 d5d3d45160f..bec21791c90 100644
--- 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 7569d78b42d..0532f013383 100644
--- 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 4b6193f312c..8172cae6b47 100644
--- 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 13ae1bbb7f6..14b21a242bd 100644
--- 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 19251a2b97e..02ba8f16996 100644
--- a/src/test/run-pass/command-line-args.rs
+++ b/src/test/run-pass/command-line-args.rs
@@ -1,3 +1,3 @@
 
 
-fn main(args: [str]) { log_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 4345170818e..854711286dd 100644
--- 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 bfc75cf68d7..6f33b369620 100644
--- 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 001268e5fd6..7848d9b9bd5 100644
--- 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 52d3a355127..347ea13f005 100644
--- 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 16dd8b8fbe2..748044893ed 100644
--- 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 089047d6eed..f15c0f4121d 100644
--- 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 0f494131ab8..2784b16b99a 100644
--- 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 768a75878f4..768f2aba16d 100644
--- 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 6c61cf619a1..8942201fa9c 100644
--- 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 4baf413b4c9..082a7d65bca 100644
--- 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 f0085418fdb..c9cfbe40e0e 100644
--- 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 a57e897f506..d13e08c7ed3 100644
--- 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 5a3486538ae..68106f29861 100644
--- 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 947e0a0a345..5919ee91b44 100644
--- 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 81b26a42e1b..90356d15b4b 100644
--- 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 1927895c4a0..f44ef370e2c 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -5,6 +5,6 @@ fn id<copy T>(t: T) -> T { ret t; }
 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 afab511d0fe..4746a588a56 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -5,6 +5,6 @@ fn id<send T>(t: T) -> T { ret t; }
 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 a38673c5e20..032a5c3f9d6 100644
--- 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 51fd9d266a9..4f0bd22944e 100644
--- 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 1da5e7ecbec..7333350e3b2 100644
--- 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 64c7d969f23..ac2d6f5aad3 100644
--- 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 d3d8c4cc98b..2186b12022d 100644
--- 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 0b503e50f1f..ab693787182 100644
--- a/src/test/run-pass/generic-obj.rs
+++ b/src/test/run-pass/generic-obj.rs
@@ -13,9 +13,9 @@ obj buf<copy T>(data: {_0: T, _1: T, _2: 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 ba7f5858b4e..7b03e75ef08 100644
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -6,12 +6,12 @@ tag noption<T> { some(T); }
 
 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 954fde38d4d..b6485834241 100644
--- 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 38cf67b3baa..2b5f81d526d 100644
--- 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 204fa517302..8670a53ac33 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -52,7 +52,7 @@ mod map_reduce {
                 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 78acc18e643..11ebbcea822 100644
--- 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 58b61be0b05..f3d35f52a3a 100644
--- a/src/test/run-pass/if-check-precond.rs
+++ b/src/test/run-pass/if-check-precond.rs
@@ -4,7 +4,7 @@ pure fn even(x: uint) -> bool {
     } 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 af41543041b..59766164018 100644
--- a/src/test/run-pass/if-check.rs
+++ b/src/test/run-pass/if-check.rs
@@ -6,7 +6,7 @@ pure fn even(x: uint) -> bool {
 
 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 16a132c1d5d..b8a74753895 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -3,9 +3,9 @@ use std;
 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 68a7d6877d1..49a576ac1b1 100644
--- 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 fdaca253e54..f7d9c761af7 100644
--- a/src/test/run-pass/import8.rs
+++ b/src/test/run-pass/import8.rs
@@ -3,7 +3,7 @@ import foo::x;
 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 81bad1e91d1..0351736b2a3 100644
--- 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 e30e9cf7ecd..716b9dd16db 100644
--- 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 29c5bfecf27..2c0a2ae7afc 100644
--- 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 a03e7eaece8..c01457ed491 100644
--- 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 56206422c2e..db54df09967 100644
--- 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 d549b247933..c02fc34ae8b 100644
--- 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 3ccf97aba52..87dc1e6d89b 100644
--- 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 17d0eda392b..0eeb306d4fd 100644
--- 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 9aef748ce09..2639e9e2a0a 100644
--- 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 fb0a9979c64..392665eee06 100644
--- 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 5bf47adcf06..67ec699e070 100644
--- 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 de87837a31a..d36551c723e 100644
--- 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 305f84d766c..5b4ae8799c8 100644
--- a/src/test/run-pass/log-err-phi.rs
+++ b/src/test/run-pass/log-err-phi.rs
@@ -1,3 +1,3 @@
 
 
-fn main() { if false { log_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 88603bd1f7b..984683d8ad2 100644
--- 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 c4d74b65171..856682dca07 100644
--- 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 feb95f7e363..044e77d5f1e 100644
--- 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 05ebb5ac50f..e5afe657142 100644
--- 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 596103af7fc..f0493017671 100644
--- 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 c07b4ab97a6..09481d7e084 100644
--- 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 c37a03ed838..f1f998b376f 100644
--- a/src/test/run-pass/obj-recursion.rs
+++ b/src/test/run-pass/obj-recursion.rs
@@ -6,7 +6,7 @@ type adder =
     };
 
 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 1670febe0e4..5ceab392c2e 100644
--- 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 96214d9669f..75fb607b866 100644
--- 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 064d1e47347..b2bea85db4c 100644
--- 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 b9bcc80e486..e6a14e9128d 100644
--- 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 b9eecbed2f1..98a137d3eb5 100644
--- 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 73ada106f43..8b2274817f7 100644
--- 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 56f70a64576..20e4f27627e 100644
--- 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 9348dcd50c2..1261878db2e 100644
--- 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 e3609bf1d76..db8b86fe4a4 100644
--- 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 5a6255038f6..3c19958fa31 100644
--- 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 2edc604deb8..84bc0759502 100644
--- 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 1a693bc3b1a..dd430bc7089 100644
--- 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 9132f650772..a50e5ed82d7 100644
--- 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 887df2ef3f3..e320d1b6d01 100644
--- 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 38e473f082c..d0c4a2f270b 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -6,7 +6,7 @@ tag clam<T> { a(T, int); b; }
 
 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 38600ba9f7e..68e0f22f2f8 100644
--- a/src/test/run-pass/spawn-fn.rs
+++ b/src/test/run-pass/spawn-fn.rs
@@ -6,7 +6,7 @@ import task;
 
 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 664f3e33b06..413474efd92 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -5,5 +5,5 @@ import task::spawn_joinable;
 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 431eee700d1..52ceb4c27ab 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -6,7 +6,7 @@ import task;
 
 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 1ecc5e8b3b9..6d22149824f 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -7,15 +7,15 @@ fn main() { spawn((10, 20, 30, 40, 50, 60, 70, 80, 90), child); }
 
 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 8176b30f9f2..102a226e298 100644
--- a/src/test/run-pass/stateful-obj.rs
+++ b/src/test/run-pass/stateful-obj.rs
@@ -11,9 +11,9 @@ obj counter(mutable x: int) {
 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 5b6b36ba4d6..dd689afff95 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -7,7 +7,7 @@ import str;
 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 69ea90b126c..69d26469677 100644
--- 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 5911cb30e1b..ef7e2c71eaa 100644
--- 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 34d867e30b6..30ea8e0efc4 100644
--- 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 9612a7749cb..de9dffbaca3 100644
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -3,251 +3,251 @@ import std::os;
 
 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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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, 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 fdcdfac1ee9..c5a26bcaad2 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -2,8 +2,8 @@ use std;
 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 3153f60d2f3..6ec80db8d55 100644
--- 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 901cc990864..992fe0986ca 100644
--- a/src/test/run-pass/tail-cps.rs
+++ b/src/test/run-pass/tail-cps.rs
@@ -8,12 +8,12 @@ fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
 
 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 b512da1b204..d54b31b07b5 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -8,7 +8,7 @@ import task;
 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 ee4a8338599..84e4825ec9b 100644
--- 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 0381fabb2d3..e37eb15ce39 100644
--- 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 78b50e614fd..407939c9e65 100644
--- 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 3409c8d4c54..b27d0669c61 100644
--- 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 77d86081c06..703fb3fc2a0 100644
--- 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 7fbfe5e2916..85a9fb8dfbd 100644
--- 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 417e537a905..2f09d1c6b4f 100644
--- 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 cea3d49772e..487b440ee42 100644
--- 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 21159a32e73..bcf3469281b 100644
--- 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 4b545eb9c79..ef74e70eede 100644
--- 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 d6908607130..a8ca302b395 100644
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -4,7 +4,7 @@ tag bar { u(~int); w(int); }
 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 52181a0cf5a..2ccf2394bed 100644
--- a/src/test/run-pass/unreachable-code.rs
+++ b/src/test/run-pass/unreachable-code.rs
@@ -19,13 +19,13 @@ fn bind_id_2() { bind id(ret); }
 
 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 d30f7d65afb..5e77cf8f684 100644
--- 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 4481d65e9f4..cd54239ec56 100644
--- 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 ddca218ada2..7dd73a14342 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -8,8 +8,8 @@ use std (name = "std",
 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 778fa22c446..b2288162bd6 100644
--- 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 7604f74f7b2..08a81ba6e92 100644
--- 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 c41293dadb6..7b27feab6f4 100644
--- 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 ad88a315ab2..e8a39b2a055 100644
--- 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 3870ebdc63e..6b110e9e275 100644
--- 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 da7101349a3..336633623be 100644
--- 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 06d7a1492f0..9054d765e04 100644
--- 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 65759d537a9..4f207a43154 100644
--- 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 6f73e9780f9..2fe5f8b432b 100644
--- 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 fc4faf46008..765f87de7b2 100644
--- 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 ea7c3916662..ba5145870e1 100644
--- a/src/test/run-pass/yield2.rs
+++ b/src/test/run-pass/yield2.rs
@@ -3,5 +3,5 @@ use std;
 
 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 f48260f4cce..a94b1739b32 100644
--- 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 f28edd03e36..0810253c9fd 100644
--- 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 fca25f70fa5..a0ab02a898f 100644
--- a/src/test/stdtest/fs.rs
+++ b/src/test/stdtest/fs.rs
@@ -7,7 +7,7 @@ import vec;
 #[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 5d397f6e702..52b68f888c4 100644
--- 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 742ec39d828..7e481fabea0 100644
--- a/src/test/stdtest/io.rs
+++ b/src/test/stdtest/io.rs
@@ -9,9 +9,9 @@ import result;
 #[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 2d1a64da753..7f7b2c4f3b3 100644
--- 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 bb07fae6899..e711288c615 100644
--- a/src/test/stdtest/path.rs
+++ b/src/test/stdtest/path.rs
@@ -11,8 +11,8 @@ import std::os;
 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 cac57233ea1..67e16942e41 100644
--- 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 50f7bd27427..b4371b2c3b4 100644
--- 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 e59134830d2..1460fb87f80 100644
--- a/src/test/stdtest/rand.rs
+++ b/src/test/stdtest/rand.rs
@@ -8,33 +8,33 @@ import str;
 #[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 e0d68d21756..fae791c3d9c 100644
--- 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 9a8f4686920..83d885797bf 100644
--- 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 0e819bac4c8..c3f0e53bac5 100644
--- 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 test_split() {
 #[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 test_split_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 8a47d9c3039..632f42c0f6b 100644
--- a/src/test/stdtest/sys.rs
+++ b/src/test/stdtest/sys.rs
@@ -4,7 +4,7 @@ import sys;
 
 #[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 1059f9084e3..31299e703be 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -35,7 +35,7 @@ fn test_join_chan() {
     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 test_join_convenient() {
 #[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);*/