diff --git a/mk/crates.mk b/mk/crates.mk
index 2a6e38a6d3d..7c12b4edacb 100644
--- a/mk/crates.mk
+++ b/mk/crates.mk
@@ -51,7 +51,7 @@
 
 TARGET_CRATES := std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-		 workcache url
+		 workcache url log
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -60,15 +60,15 @@ DEPS_std := native:rustrt native:compiler-rt native:backtrace
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize collections
+DEPS_syntax := std term serialize collections log
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections time
+              collections time log
 DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
                 test time
 DEPS_flate := std native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
-DEPS_serialize := std collections
+DEPS_serialize := std collections log
 DEPS_term := std collections
 DEPS_semver := std
 DEPS_uuid := std serialize rand
@@ -83,6 +83,7 @@ DEPS_time := std serialize
 DEPS_rand := std
 DEPS_url := std collections
 DEPS_workcache := std serialize collections std
+DEPS_log := std sync
 
 TOOL_DEPS_compiletest := test green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc native
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 35e1c242fe2..a1fcddcf6b3 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #[crate_type = "bin"];
+#[feature(phase)];
 
 #[allow(non_camel_case_types)];
 #[deny(warnings)];
@@ -16,6 +17,8 @@
 
 extern crate test;
 extern crate getopts;
+#[phase(link, syntax)]
+extern crate log;
 
 use std::os;
 use std::io;
diff --git a/src/doc/rust.md b/src/doc/rust.md
index f0b9a430771..7233288a813 100644
--- a/src/doc/rust.md
+++ b/src/doc/rust.md
@@ -1055,7 +1055,7 @@ output slot type would normally be. For example:
 
 ~~~~
 fn my_err(s: &str) -> ! {
-    info!("{}", s);
+    println!("{}", s);
     fail!();
 }
 ~~~~
@@ -3885,6 +3885,9 @@ Rust provides several macros to log information. Here's a simple Rust program
 that demonstrates all four of them:
 
 ~~~~
+#[feature(phase)];
+#[phase(syntax, link)] extern crate log;
+
 fn main() {
     error!("This is an error log")
     warn!("This is a warn log")
diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md
index 9b4d4444da4..cdb521b96c4 100644
--- a/src/doc/tutorial.md
+++ b/src/doc/tutorial.md
@@ -796,7 +796,7 @@ unit, `()`, as the empty tuple if you like).
 ~~~~
 let mytup: (int, int, f64) = (10, 20, 30.0);
 match mytup {
-  (a, b, c) => info!("{}", a + b + (c as int))
+  (a, b, c) => println!("{}", a + b + (c as int))
 }
 ~~~~
 
@@ -813,7 +813,7 @@ For example:
 struct MyTup(int, int, f64);
 let mytup: MyTup = MyTup(10, 20, 30.0);
 match mytup {
-  MyTup(a, b, c) => info!("{}", a + b + (c as int))
+  MyTup(a, b, c) => println!("{}", a + b + (c as int))
 }
 ~~~~
 
@@ -1794,7 +1794,7 @@ use std::task::spawn;
 
 // proc is the closure which will be spawned.
 spawn(proc() {
-    debug!("I'm a new task")
+    println!("I'm a new task")
 });
 ~~~~
 
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 94c1131949c..24478ff8c5f 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -20,7 +20,7 @@
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
-#[feature(macro_rules, managed_boxes, default_type_params)];
+#[feature(macro_rules, managed_boxes, default_type_params, phase)];
 
 // NOTE remove the following two attributes after the next snapshot.
 #[allow(unrecognized_lint)];
@@ -30,6 +30,7 @@
 extern crate rand;
 
 #[cfg(test)] extern crate test;
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 pub use bitv::Bitv;
 pub use btree::BTree;
diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs
index 8733c127194..2482359c632 100644
--- a/src/libflate/lib.rs
+++ b/src/libflate/lib.rs
@@ -18,9 +18,11 @@ Simple compression
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 #[license = "MIT/ASL2"];
-#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
+#[feature(phase)];
+
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 use std::libc::{c_void, size_t, c_int};
 use std::libc;
diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index 69f6ad11431..6aa064bb69a 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -86,7 +86,9 @@
 #[allow(missing_doc)];
 #[allow(deprecated_owned_vector)];
 
-#[feature(globs)];
+#[feature(globs, phase)];
+
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 use std::cmp::Eq;
 use std::result::{Err, Ok};
diff --git a/src/libgreen/lib.rs b/src/libgreen/lib.rs
index c697b1c8fd7..78ea407d4eb 100644
--- a/src/libgreen/lib.rs
+++ b/src/libgreen/lib.rs
@@ -172,10 +172,11 @@
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
 // NB this does *not* include globs, please keep it that way.
-#[feature(macro_rules)];
+#[feature(macro_rules, phase)];
 #[allow(visible_private_types)];
 #[allow(deprecated_owned_vector)];
 
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 extern crate rand;
 
 use std::mem::replace;
diff --git a/src/libgreen/task.rs b/src/libgreen/task.rs
index 7c29a6496f9..97924eca1b9 100644
--- a/src/libgreen/task.rs
+++ b/src/libgreen/task.rs
@@ -178,14 +178,13 @@ impl GreenTask {
                      f: proc()) -> ~GreenTask {
         let TaskOpts {
             notify_chan, name, stack_size,
-            stderr, stdout, logger,
+            stderr, stdout,
         } = opts;
 
         let mut green = GreenTask::new(pool, stack_size, f);
         {
             let task = green.task.get_mut_ref();
             task.name = name;
-            task.logger = logger;
             task.stderr = stderr;
             task.stdout = stdout;
             match notify_chan {
diff --git a/src/liblog/directive.rs b/src/liblog/directive.rs
new file mode 100644
index 00000000000..d33ad0c8185
--- /dev/null
+++ b/src/liblog/directive.rs
@@ -0,0 +1,134 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cmp;
+use std::vec_ng::Vec;
+
+#[deriving(Show, Clone)]
+pub struct LogDirective {
+    name: Option<~str>,
+    level: u32,
+}
+
+static LOG_LEVEL_NAMES: [&'static str, ..4] = ["error", "warn", "info",
+                                               "debug"];
+
+/// Parse an individual log level that is either a number or a symbolic log level
+fn parse_log_level(level: &str) -> Option<u32> {
+    from_str::<u32>(level).or_else(|| {
+        let pos = LOG_LEVEL_NAMES.iter().position(|&name| name == level);
+        pos.map(|p| p as u32 + 1)
+    }).map(|p| cmp::min(p, ::MAX_LOG_LEVEL))
+}
+
+/// Parse a logging specification string (e.g: "crate1,crate2::mod3,crate3::x=1")
+/// and return a vector with log directives.
+///
+/// Valid log levels are 0-255, with the most likely ones being 1-4 (defined in
+/// std::).  Also supports string log levels of error, warn, info, and debug
+pub fn parse_logging_spec(spec: &str) -> Vec<LogDirective> {
+    let mut dirs = Vec::new();
+    for s in spec.split(',') {
+        if s.len() == 0 { continue }
+        let mut parts = s.split('=');
+        let (log_level, name) = match (parts.next(), parts.next(), parts.next()) {
+            (Some(part0), None, None) => {
+                // if the single argument is a log-level string or number,
+                // treat that as a global fallback
+                match parse_log_level(part0) {
+                    Some(num) => (num, None),
+                    None => (::MAX_LOG_LEVEL, Some(part0)),
+                }
+            }
+            (Some(part0), Some(part1), None) => {
+                match parse_log_level(part1) {
+                    Some(num) => (num, Some(part0)),
+                    _ => {
+                        println!("warning: invalid logging spec '{}', \
+                                 ignoring it", part1);
+                        continue
+                    }
+                }
+            },
+            _ => {
+                println!("warning: invalid logging spec '{}', \
+                         ignoring it", s);
+                continue
+            }
+        };
+        dirs.push(LogDirective {
+            name: name.map(|s| s.to_owned()),
+            level: log_level,
+        });
+    }
+    return dirs;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_logging_spec;
+
+    #[test]
+    fn parse_logging_spec_valid() {
+        let dirs = parse_logging_spec("crate1::mod1=1,crate1::mod2,crate2=4");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 3);
+        assert_eq!(dirs[0].name, Some(~"crate1::mod1"));
+        assert_eq!(dirs[0].level, 1);
+
+        assert_eq!(dirs[1].name, Some(~"crate1::mod2"));
+        assert_eq!(dirs[1].level, ::MAX_LOG_LEVEL);
+
+        assert_eq!(dirs[2].name, Some(~"crate2"));
+        assert_eq!(dirs[2].level, 4);
+    }
+
+    #[test]
+    fn parse_logging_spec_invalid_crate() {
+        // test parse_logging_spec with multiple = in specification
+        let dirs = parse_logging_spec("crate1::mod1=1=2,crate2=4");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].name, Some(~"crate2"));
+        assert_eq!(dirs[0].level, 4);
+    }
+
+    #[test]
+    fn parse_logging_spec_invalid_log_level() {
+        // test parse_logging_spec with 'noNumber' as log level
+        let dirs = parse_logging_spec("crate1::mod1=noNumber,crate2=4");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].name, Some(~"crate2"));
+        assert_eq!(dirs[0].level, 4);
+    }
+
+    #[test]
+    fn parse_logging_spec_string_log_level() {
+        // test parse_logging_spec with 'warn' as log level
+        let dirs = parse_logging_spec("crate1::mod1=wrong,crate2=warn");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].name, Some(~"crate2"));
+        assert_eq!(dirs[0].level, ::WARN);
+    }
+
+    #[test]
+    fn parse_logging_spec_global() {
+        // test parse_logging_spec with no crate
+        let dirs = parse_logging_spec("warn,crate2=4");
+        let dirs = dirs.as_slice();
+        assert_eq!(dirs.len(), 2);
+        assert_eq!(dirs[0].name, None);
+        assert_eq!(dirs[0].level, 2);
+        assert_eq!(dirs[1].name, Some(~"crate2"));
+        assert_eq!(dirs[1].level, 4);
+    }
+}
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
new file mode 100644
index 00000000000..6d2afa2a643
--- /dev/null
+++ b/src/liblog/lib.rs
@@ -0,0 +1,340 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+
+Utilities for program-wide and customizable logging
+
+This module is used by the compiler when emitting output for the logging family
+of macros. The methods of this module shouldn't necessarily be used directly,
+but rather through the logging macros defined.
+
+There are five macros that the logging subsystem uses:
+
+* `log!(level, ...)` - the generic logging macro, takes a level as a u32 and any
+                       related `format!` arguments
+* `debug!(...)` - a macro hard-wired to the log level of `DEBUG`
+* `info!(...)` - a macro hard-wired to the log level of `INFO`
+* `warn!(...)` - a macro hard-wired to the log level of `WARN`
+* `error!(...)` - a macro hard-wired to the log level of `ERROR`
+
+All of these macros use std::the same style of syntax as the `format!` syntax
+extension. Details about the syntax can be found in the documentation of
+`std::fmt` along with the Rust tutorial/manual.
+
+If you want to check at runtime if a given logging level is enabled (e.g. if the
+information you would want to log is expensive to produce), you can use std::the
+following macro:
+
+* `log_enabled!(level)` - returns true if logging of the given level is enabled
+
+## Enabling logging
+
+Log levels are controlled on a per-module basis, and by default all logging is
+disabled except for `error!` (a log level of 1). Logging is controlled via the
+`RUST_LOG` environment variable. The value of this environment variable is a
+comma-separated list of logging directives. A logging directive is of the form:
+
+```notrust
+path::to::module=log_level
+```
+
+The path to the module is rooted in the name of the crate it was compiled for,
+so if your program is contained in a file `hello.rs`, for example, to turn on
+logging for this file you would use std::a value of `RUST_LOG=hello`.
+Furthermore, this path is a prefix-search, so all modules nested in the
+specified module will also have logging enabled.
+
+The actual `log_level` is optional to specify. If omitted, all logging will be
+enabled. If specified, the it must be either a numeric in the range of 1-255, or
+it must be one of the strings `debug`, `error`, `info`, or `warn`. If a numeric
+is specified, then all logging less than or equal to that numeral is enabled.
+For example, if logging level 3 is active, error, warn, and info logs will be
+printed, but debug will be omitted.
+
+As the log level for a module is optional, the module to enable logging for is
+also optional. If only a `log_level` is provided, then the global log level for
+all modules is set to this value.
+
+Some examples of valid values of `RUST_LOG` are:
+
+```notrust
+hello                // turns on all logging for the 'hello' module
+info                 // turns on all info logging
+hello=debug          // turns on debug logging for 'hello'
+hello=3              // turns on info logging for 'hello'
+hello,std::option    // turns on hello, and std's option logging
+error,hello=warn     // turn on global error logging and also warn for hello
+```
+
+## Performance and Side Effects
+
+Each of these macros will expand to code similar to:
+
+```rust,ignore
+if log_level <= my_module_log_level() {
+    ::log::log(log_level, format!(...));
+}
+```
+
+What this means is that each of these macros are very cheap at runtime if
+they're turned off (just a load and an integer comparison). This also means that
+if logging is disabled, none of the components of the log will be executed.
+
+*/
+
+#[crate_id = "log#0.10-pre"];
+#[license = "MIT/ASL2"];
+#[crate_type = "rlib"];
+#[crate_type = "dylib"];
+#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      html_root_url = "http://static.rust-lang.org/doc/master")];
+
+#[feature(macro_rules)];
+#[deny(missing_doc)];
+
+extern crate sync;
+
+use std::cast;
+use std::fmt;
+use std::io::LineBufferedWriter;
+use std::io;
+use std::local_data;
+use std::os;
+use std::rt;
+use std::vec;
+use std::vec_ng::Vec;
+
+use sync::one::{Once, ONCE_INIT};
+
+pub mod macros;
+mod directive;
+
+/// Maximum logging level of a module that can be specified. Common logging
+/// levels are found in the DEBUG/INFO/WARN/ERROR constants.
+pub static MAX_LOG_LEVEL: u32 = 255;
+
+/// The default logging level of a crate if no other is specified.
+static DEFAULT_LOG_LEVEL: u32 = 1;
+
+/// An unsafe constant that is the maximum logging level of any module
+/// specified. This is the first line of defense to determining whether a
+/// logging statement should be run.
+static mut LOG_LEVEL: u32 = MAX_LOG_LEVEL;
+
+static mut DIRECTIVES: *Vec<directive::LogDirective> =
+    0 as *Vec<directive::LogDirective>;
+
+/// Debug log level
+pub static DEBUG: u32 = 4;
+/// Info log level
+pub static INFO: u32 = 3;
+/// Warn log level
+pub static WARN: u32 = 2;
+/// Error log level
+pub static ERROR: u32 = 1;
+
+local_data_key!(local_logger: ~Logger)
+
+/// A trait used to represent an interface to a task-local logger. Each task
+/// can have its own custom logger which can respond to logging messages
+/// however it likes.
+pub trait Logger {
+    /// Logs a single message described by the `args` structure. The level is
+    /// provided in case you want to do things like color the message, etc.
+    fn log(&mut self, level: u32, args: &fmt::Arguments);
+}
+
+struct DefaultLogger {
+    handle: LineBufferedWriter<io::stdio::StdWriter>,
+}
+
+impl Logger for DefaultLogger {
+    // by default, just ignore the level
+    fn log(&mut self, _level: u32, args: &fmt::Arguments) {
+        match fmt::writeln(&mut self.handle, args) {
+            Err(e) => fail!("failed to log: {}", e),
+            Ok(()) => {}
+        }
+    }
+}
+
+impl Drop for DefaultLogger {
+    fn drop(&mut self) {
+        // FIXME(#12628): is failure the right thing to do?
+        match self.handle.flush() {
+            Err(e) => fail!("failed to flush a logger: {}", e),
+            Ok(()) => {}
+        }
+    }
+}
+
+/// This function is called directly by the compiler when using the logging
+/// macros. This function does not take into account whether the log level
+/// specified is active or not, it will always log something if this method is
+/// called.
+///
+/// It is not recommended to call this function directly, rather it should be
+/// invoked through the logging family of macros.
+pub fn log(level: u32, args: &fmt::Arguments) {
+    // Completely remove the local logger from TLS in case anyone attempts to
+    // frob the slot while we're doing the logging. This will destroy any logger
+    // set during logging.
+    let mut logger = local_data::pop(local_logger).unwrap_or_else(|| {
+        ~DefaultLogger { handle: io::stderr() } as ~Logger
+    });
+    logger.log(level, args);
+    local_data::set(local_logger, logger);
+}
+
+/// Getter for the global log level. This is a function so that it can be called
+/// safely
+#[doc(hidden)]
+#[inline(always)]
+pub fn log_level() -> u32 { unsafe { LOG_LEVEL } }
+
+/// Replaces the task-local logger with the specified logger, returning the old
+/// logger.
+pub fn set_logger(logger: ~Logger) -> Option<~Logger> {
+    let prev = local_data::pop(local_logger);
+    local_data::set(local_logger, logger);
+    return prev;
+}
+
+/// Tests whether a given module's name is enabled for a particular level of
+/// logging. This is the second layer of defense about determining whether a
+/// module's log statement should be emitted or not.
+#[doc(hidden)]
+pub fn mod_enabled(level: u32, module: &str) -> bool {
+    static mut INIT: Once = ONCE_INIT;
+    unsafe { INIT.doit(init); }
+
+    // It's possible for many threads are in this function, only one of them
+    // will peform the global initialization, but all of them will need to check
+    // again to whether they should really be here or not. Hence, despite this
+    // check being expanded manually in the logging macro, this function checks
+    // the log level again.
+    if level > unsafe { LOG_LEVEL } { return false }
+
+    // This assertion should never get tripped unless we're in an at_exit
+    // handler after logging has been torn down and a logging attempt was made.
+    assert!(unsafe { !DIRECTIVES.is_null() });
+
+    enabled(level, module, unsafe { (*DIRECTIVES).iter() })
+}
+
+fn enabled(level: u32, module: &str,
+           iter: vec::Items<directive::LogDirective>) -> bool {
+    // Search for the longest match, the vector is assumed to be pre-sorted.
+    for directive in iter.rev() {
+        match directive.name {
+            Some(ref name) if !module.starts_with(*name) => {},
+            Some(..) | None => {
+                return level <= directive.level
+            }
+        }
+    }
+    level <= DEFAULT_LOG_LEVEL
+}
+
+/// Initialize logging for the current process.
+///
+/// This is not threadsafe at all, so initialization os performed through a
+/// `Once` primitive (and this function is called from that primitive).
+fn init() {
+    let mut directives = match os::getenv("RUST_LOG") {
+        Some(spec) => directive::parse_logging_spec(spec),
+        None => Vec::new(),
+    };
+
+    // Sort the provided directives by length of their name, this allows a
+    // little more efficient lookup at runtime.
+    directives.sort_by(|a, b| {
+        let alen = a.name.as_ref().map(|a| a.len()).unwrap_or(0);
+        let blen = b.name.as_ref().map(|b| b.len()).unwrap_or(0);
+        alen.cmp(&blen)
+    });
+
+    let max_level = {
+        let max = directives.iter().max_by(|d| d.level);
+        max.map(|d| d.level).unwrap_or(DEFAULT_LOG_LEVEL)
+    };
+
+    unsafe {
+        LOG_LEVEL = max_level;
+
+        assert!(DIRECTIVES.is_null());
+        DIRECTIVES = cast::transmute(~directives);
+
+        // Schedule the cleanup for this global for when the runtime exits.
+        rt::at_exit(proc() {
+            assert!(!DIRECTIVES.is_null());
+            let _directives: ~Vec<directive::LogDirective> =
+                cast::transmute(DIRECTIVES);
+            DIRECTIVES = 0 as *Vec<directive::LogDirective>;
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::enabled;
+    use directive::LogDirective;
+
+    #[test]
+    fn match_full_path() {
+        let dirs = [LogDirective { name: Some(~"crate2"), level: 3 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 2 }];
+        assert!(enabled(2, "crate1::mod1", dirs.iter()));
+        assert!(!enabled(3, "crate1::mod1", dirs.iter()));
+        assert!(enabled(3, "crate2", dirs.iter()));
+        assert!(!enabled(4, "crate2", dirs.iter()));
+    }
+
+    #[test]
+    fn no_match() {
+        let dirs = [LogDirective { name: Some(~"crate2"), level: 3 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 2 }];
+        assert!(!enabled(2, "crate3", dirs.iter()));
+    }
+
+    #[test]
+    fn match_beginning() {
+        let dirs = [LogDirective { name: Some(~"crate2"), level: 3 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 2 }];
+        assert!(enabled(3, "crate2::mod1", dirs.iter()));
+    }
+
+    #[test]
+    fn match_beginning_longest_match() {
+        let dirs = [LogDirective { name: Some(~"crate2"), level: 3 },
+                    LogDirective { name: Some(~"crate2::mod"), level: 4 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 2 }];
+        assert!(enabled(4, "crate2::mod1", dirs.iter()));
+        assert!(!enabled(4, "crate2", dirs.iter()));
+    }
+
+    #[test]
+    fn match_default() {
+        let dirs = [LogDirective { name: None, level: 3 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 2 }];
+        assert!(enabled(2, "crate1::mod1", dirs.iter()));
+        assert!(enabled(3, "crate2::mod2", dirs.iter()));
+    }
+
+    #[test]
+    fn zero_level() {
+        let dirs = [LogDirective { name: None, level: 3 },
+                    LogDirective { name: Some(~"crate1::mod1"), level: 0 }];
+        assert!(!enabled(1, "crate1::mod1", dirs.iter()));
+        assert!(enabled(3, "crate2::mod2", dirs.iter()));
+    }
+}
diff --git a/src/liblog/macros.rs b/src/liblog/macros.rs
new file mode 100644
index 00000000000..1560eeebfca
--- /dev/null
+++ b/src/liblog/macros.rs
@@ -0,0 +1,141 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Logging macros
+
+#[macro_escape];
+
+/// The standard logging macro
+///
+/// This macro will generically log over a provided level (of type u32) with a
+/// format!-based argument list. See documentation in `std::fmt` for details on
+/// how to use the syntax.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// log!(log::DEBUG, "this is a debug message");
+/// log!(log::WARN, "this is a warning {}", "message");
+/// log!(6, "this is a custom logging level: {level}", level=6);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! log(
+    ($lvl:expr, $($arg:tt)+) => ({
+        let lvl = $lvl;
+        if log_enabled!(lvl) {
+            format_args!(|args| { ::log::log(lvl, args) }, $($arg)+)
+        }
+    })
+)
+
+/// A convenience macro for logging at the error log level.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// # let error = 3;
+/// error!("the build has failed with error code: {}", error);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! error(
+    ($($arg:tt)*) => (log!(::log::ERROR, $($arg)*))
+)
+
+/// A convenience macro for logging at the warning log level.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// # let code = 3;
+/// warn!("you may like to know that a process exited with: {}", code);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! warn(
+    ($($arg:tt)*) => (log!(::log::WARN, $($arg)*))
+)
+
+/// A convenience macro for logging at the info log level.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// # let ret = 3;
+/// info!("this function is about to return: {}", ret);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! info(
+    ($($arg:tt)*) => (log!(::log::INFO, $($arg)*))
+)
+
+/// A convenience macro for logging at the debug log level. This macro can also
+/// be omitted at compile time by passing `--cfg ndebug` to the compiler. If
+/// this option is not passed, then debug statements will be compiled.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// debug!("x = {x}, y = {y}", x=10, y=20);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! debug(
+    ($($arg:tt)*) => (if cfg!(not(ndebug)) { log!(::log::DEBUG, $($arg)*) })
+)
+
+/// A macro to test whether a log level is enabled for the current module.
+///
+/// # Example
+///
+/// ```
+/// #[feature(phase)];
+/// #[phase(syntax, link)] extern crate log;
+///
+/// # fn main() {
+/// # struct Point { x: int, y: int }
+/// # fn some_expensive_computation() -> Point { Point { x: 1, y: 2 } }
+/// if log_enabled!(log::DEBUG) {
+///     let x = some_expensive_computation();
+///     debug!("x.x = {}, x.y = {}", x.x, x.y);
+/// }
+/// # }
+/// ```
+#[macro_export]
+macro_rules! log_enabled(
+    ($lvl:expr) => ({
+        let lvl = $lvl;
+        (lvl != ::log::DEBUG || cfg!(not(ndebug))) &&
+        lvl <= ::log::log_level() &&
+        ::log::mod_enabled(lvl, module_path!())
+    })
+)
diff --git a/src/libnative/io/file_unix.rs b/src/libnative/io/file_unix.rs
index ff1ff9a569d..1d7938be226 100644
--- a/src/libnative/io/file_unix.rs
+++ b/src/libnative/io/file_unix.rs
@@ -209,7 +209,8 @@ impl Drop for Inner {
         if self.close_on_drop && self.fd > libc::STDERR_FILENO {
             let n = unsafe { libc::close(self.fd) };
             if n != 0 {
-                warn!("error {} when closing file descriptor {}", n, self.fd);
+                println!("error {} when closing file descriptor {}", n,
+                         self.fd);
             }
         }
     }
@@ -362,13 +363,10 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
     let mut buf = Vec::<u8>::with_capacity(size as uint);
     let ptr = buf.as_mut_slice().as_mut_ptr() as *mut dirent_t;
 
-    debug!("os::list_dir -- BEFORE OPENDIR");
-
     let dir_ptr = p.with_ref(|buf| unsafe { opendir(buf) });
 
     if dir_ptr as uint != 0 {
         let mut paths = ~[];
-        debug!("os::list_dir -- opendir() SUCCESS");
         let mut entry_ptr = 0 as *mut dirent_t;
         while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
             if entry_ptr.is_null() { break }
diff --git a/src/libnative/io/mod.rs b/src/libnative/io/mod.rs
index a054ee66391..615ed80a648 100644
--- a/src/libnative/io/mod.rs
+++ b/src/libnative/io/mod.rs
@@ -112,10 +112,7 @@ fn translate_error(errno: i32, detail: bool) -> IoError {
             libc::ERROR_INVALID_FUNCTION => (io::InvalidInput,
                                              "illegal operation on a directory"),
 
-            x => {
-                debug!("ignoring {}: {}", x, os::last_os_error());
-                (io::OtherIoError, "unknown error")
-            }
+            _ => (io::OtherIoError, "unknown error")
         }
     }
 
@@ -141,10 +138,7 @@ fn translate_error(errno: i32, detail: bool) -> IoError {
             x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
                 (io::ResourceUnavailable, "resource temporarily unavailable"),
 
-            x => {
-                debug!("ignoring {}: {}", x, os::last_os_error());
-                (io::OtherIoError, "unknown error")
-            }
+            _ => (io::OtherIoError, "unknown error")
         }
     }
 
diff --git a/src/libnative/io/timer_timerfd.rs b/src/libnative/io/timer_timerfd.rs
index 1b0e08ca6fb..a8018bec0a6 100644
--- a/src/libnative/io/timer_timerfd.rs
+++ b/src/libnative/io/timer_timerfd.rs
@@ -89,10 +89,8 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
         };
 
         let mut incoming = false;
-        debug!("{} events to process", n);
         for event in events.slice_to(n as uint).iter() {
             let fd = event.data as libc::c_int;
-            debug!("data on fd {} (input = {})", fd, input);
             if fd == input {
                 let mut buf = [0, ..1];
                 // drain the input file descriptor of its input
diff --git a/src/libnative/task.rs b/src/libnative/task.rs
index 8510b50777a..7a42d1bfee3 100644
--- a/src/libnative/task.rs
+++ b/src/libnative/task.rs
@@ -59,12 +59,11 @@ pub fn spawn(f: proc()) {
 pub fn spawn_opts(opts: TaskOpts, f: proc()) {
     let TaskOpts {
         notify_chan, name, stack_size,
-        logger, stderr, stdout,
+        stderr, stdout,
     } = opts;
 
     let mut task = ~Task::new();
     task.name = name;
-    task.logger = logger;
     task.stderr = stderr;
     task.stdout = stdout;
     match notify_chan {
diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index 25081017f07..1c1121f0940 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -501,10 +501,9 @@ pub mod write {
  *    system linkers understand.
  */
 
-pub fn find_crate_id(attrs: &[ast::Attribute],
-                     output: &OutputFilenames) -> CrateId {
+pub fn find_crate_id(attrs: &[ast::Attribute], out_filestem: &str) -> CrateId {
     match attr::find_crateid(attrs) {
-        None => from_str(output.out_filestem).unwrap(),
+        None => from_str(out_filestem).unwrap(),
         Some(s) => s,
     }
 }
@@ -518,10 +517,9 @@ pub fn crate_id_hash(crate_id: &CrateId) -> ~str {
     truncated_hash_result(&mut s).slice_to(8).to_owned()
 }
 
-pub fn build_link_meta(krate: &ast::Crate,
-                       output: &OutputFilenames) -> LinkMeta {
+pub fn build_link_meta(krate: &ast::Crate, out_filestem: &str) -> LinkMeta {
     let r = LinkMeta {
-        crateid: find_crate_id(krate.attrs.as_slice(), output),
+        crateid: find_crate_id(krate.attrs.as_slice(), out_filestem),
         crate_hash: Svh::calculate(krate),
     };
     info!("{}", r);
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 10b209c998b..91425b89ba6 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -46,6 +46,7 @@ use syntax::abi;
 use syntax::attr;
 use syntax::attr::{AttrMetaMethods};
 use syntax::codemap;
+use syntax::crateid::CrateId;
 use syntax::diagnostic;
 use syntax::diagnostic::Emitter;
 use syntax::ext::base::CrateLoader;
@@ -160,6 +161,15 @@ pub enum Input {
     StrInput(~str)
 }
 
+impl Input {
+    fn filestem(&self) -> ~str {
+        match *self {
+            FileInput(ref ifile) => ifile.filestem_str().unwrap().to_str(),
+            StrInput(_) => ~"rust_out",
+        }
+    }
+}
+
 pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
     -> ast::Crate {
     let krate = time(sess.time_passes(), "parsing", (), |_| {
@@ -182,6 +192,10 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
         krate.encode(&mut json);
     }
 
+    if sess.show_span() {
+        front::show_span::run(sess, &krate);
+    }
+
     krate
 }
 
@@ -194,7 +208,8 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
 /// standard library and prelude.
 pub fn phase_2_configure_and_expand(sess: Session,
                                     loader: &mut CrateLoader,
-                                    mut krate: ast::Crate)
+                                    mut krate: ast::Crate,
+                                    crate_id: &CrateId)
                                     -> (ast::Crate, syntax::ast_map::Map) {
     let time_passes = sess.time_passes();
 
@@ -223,7 +238,8 @@ pub fn phase_2_configure_and_expand(sess: Session,
     krate = time(time_passes, "expansion", krate, |krate| {
         let cfg = syntax::ext::expand::ExpansionConfig {
             loader: loader,
-            deriving_hash_type_parameter: sess.features.default_type_params.get()
+            deriving_hash_type_parameter: sess.features.default_type_params.get(),
+            crate_id: crate_id.clone(),
         };
         syntax::ext::expand::expand_crate(sess.parse_sess,
                                           cfg,
@@ -461,6 +477,9 @@ pub fn stop_after_phase_1(sess: Session) -> bool {
         debug!("invoked with --parse-only, returning early from compile_input");
         return true;
     }
+    if sess.show_span() {
+        return true;
+    }
     return sess.opts.debugging_opts & session::AST_JSON_NOEXPAND != 0;
 }
 
@@ -484,7 +503,7 @@ fn write_out_deps(sess: Session,
                   input: &Input,
                   outputs: &OutputFilenames,
                   krate: &ast::Crate) -> io::IoResult<()> {
-    let id = link::find_crate_id(krate.attrs.as_slice(), outputs);
+    let id = link::find_crate_id(krate.attrs.as_slice(), outputs.out_filestem);
 
     let mut out_filenames = Vec::new();
     for output_type in sess.opts.output_types.iter() {
@@ -547,22 +566,21 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &Input,
     // We need nested scopes here, because the intermediate results can keep
     // large chunks of memory alive and we want to free them as soon as
     // possible to keep the peak memory usage low
-    let (outputs, trans) = {
+    let outputs;
+    let trans = {
         let (expanded_crate, ast_map) = {
             let krate = phase_1_parse_input(sess, cfg, input);
-            if sess.show_span() {
-                front::show_span::run(sess, &krate);
-                return;
-            }
             if stop_after_phase_1(sess) { return; }
-            let loader = &mut Loader::new(sess);
-            phase_2_configure_and_expand(sess, loader, krate)
-        };
-        let outputs = build_output_filenames(input,
+            outputs = build_output_filenames(input,
                                              outdir,
                                              output,
-                                             expanded_crate.attrs.as_slice(),
+                                             krate.attrs.as_slice(),
                                              sess);
+            let loader = &mut Loader::new(sess);
+            let id = link::find_crate_id(krate.attrs.as_slice(),
+                                         outputs.out_filestem);
+            phase_2_configure_and_expand(sess, loader, krate, &id)
+        };
 
         write_out_deps(sess, input, &outputs, &expanded_crate).unwrap();
 
@@ -570,9 +588,7 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &Input,
 
         let analysis = phase_3_run_analysis_passes(sess, &expanded_crate, ast_map);
         if stop_after_phase_3(sess) { return; }
-        let trans = phase_4_translate_to_llvm(sess, expanded_crate,
-                                              &analysis, &outputs);
-        (outputs, trans)
+        phase_4_translate_to_llvm(sess, expanded_crate, &analysis, &outputs)
     };
     phase_5_run_llvm_passes(sess, &trans, &outputs);
     if stop_after_phase_5(sess) { return; }
@@ -645,11 +661,13 @@ pub fn pretty_print_input(sess: Session,
                           input: &Input,
                           ppm: PpMode) {
     let krate = phase_1_parse_input(sess, cfg, input);
+    let id = link::find_crate_id(krate.attrs.as_slice(), input.filestem());
 
     let (krate, ast_map, is_expanded) = match ppm {
         PpmExpanded | PpmExpandedIdentified | PpmTyped => {
             let loader = &mut Loader::new(sess);
-            let (krate, ast_map) = phase_2_configure_and_expand(sess, loader, krate);
+            let (krate, ast_map) = phase_2_configure_and_expand(sess, loader,
+                                                                krate, &id);
             (krate, Some(ast_map), true)
         }
         _ => (krate, None, false)
@@ -1137,11 +1155,7 @@ pub fn build_output_filenames(input: &Input,
                 None => Path::new(".")
             };
 
-            let mut stem = match *input {
-                // FIXME (#9639): This needs to handle non-utf8 paths
-                FileInput(ref ifile) => ifile.filestem_str().unwrap().to_str(),
-                StrInput(_) => ~"rust_out"
-            };
+            let mut stem = input.filestem();
 
             // If a crateid is present, we use it as the link name
             let crateid = attr::find_crateid(attrs);
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index d403efcf8cd..fb1ee16a9d2 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -170,6 +170,7 @@ fn generate_test_harness(sess: session::Session, krate: ast::Crate)
                              ExpansionConfig {
                                  loader: loader,
                                  deriving_hash_type_parameter: false,
+                                 crate_id: from_str("test").unwrap(),
                              }),
         path: RefCell::new(Vec::new()),
         testfns: RefCell::new(Vec::new()),
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index e7764802f17..66749cf5403 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -30,7 +30,7 @@ This API is completely unstable and subject to change.
 #[allow(deprecated)];
 #[allow(deprecated_owned_vector)];
 #[feature(macro_rules, globs, struct_variant, managed_boxes)];
-#[feature(quote, default_type_params)];
+#[feature(quote, default_type_params, phase)];
 
 extern crate flate;
 extern crate arena;
@@ -40,6 +40,8 @@ extern crate sync;
 extern crate getopts;
 extern crate collections;
 extern crate time;
+#[phase(syntax, link)]
+extern crate log;
 
 use back::link;
 use driver::session;
@@ -318,7 +320,7 @@ pub fn run_compiler(args: &[~str]) {
         let attrs = parse_crate_attrs(sess, &input);
         let t_outputs = d::build_output_filenames(&input, &odir, &ofile,
                                                   attrs.as_slice(), sess);
-        let id = link::find_crate_id(attrs.as_slice(), &t_outputs);
+        let id = link::find_crate_id(attrs.as_slice(), t_outputs.out_filestem);
 
         if crate_id {
             println!("{}", id.to_str());
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 156a4f914a9..c2f5d0806a7 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -2642,7 +2642,7 @@ pub fn trans_crate(sess: session::Session,
         }
     }
 
-    let link_meta = link::build_link_meta(&krate, output);
+    let link_meta = link::build_link_meta(&krate, output.out_filestem);
 
     // Append ".rs" to crate name as LLVM module identifier.
     //
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 58bed8a9df9..eda24fb6dc2 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -75,7 +75,9 @@ fn get_ast_and_resolve(cpath: &Path,
 
     let krate = phase_1_parse_input(sess, cfg, &input);
     let loader = &mut Loader::new(sess);
-    let (krate, ast_map) = phase_2_configure_and_expand(sess, loader, krate);
+    let id = from_str("rustdoc").unwrap();
+    let (krate, ast_map) = phase_2_configure_and_expand(sess, loader,
+                                                        krate, &id);
     let driver::driver::CrateAnalysis {
         exported_items, public_items, ty_cx, ..
     } = phase_3_run_analysis_passes(sess, &krate, ast_map);
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 3f8703b4f75..fff6e4dafb3 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -15,7 +15,7 @@
 #[crate_type = "rlib"];
 
 #[allow(deprecated_owned_vector)];
-#[feature(globs, struct_variant, managed_boxes, macro_rules)];
+#[feature(globs, struct_variant, managed_boxes, macro_rules, phase)];
 
 extern crate syntax;
 extern crate rustc;
@@ -25,6 +25,8 @@ extern crate getopts;
 extern crate collections;
 extern crate testing = "test";
 extern crate time;
+#[phase(syntax, link)]
+extern crate log;
 
 use std::cell::RefCell;
 use std::local_data;
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 5b6edeaf79d..d8b7c525538 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -61,7 +61,9 @@ pub fn run(input: &str, libs: @RefCell<HashSet<Path>>, mut test_args: ~[~str]) -
     let cfg = driver::build_configuration(sess);
     let krate = driver::phase_1_parse_input(sess, cfg, &input);
     let loader = &mut Loader::new(sess);
-    let (krate, _) = driver::phase_2_configure_and_expand(sess, loader, krate);
+    let id = from_str("rustdoc-test").unwrap();
+    let (krate, _) = driver::phase_2_configure_and_expand(sess, loader, krate,
+                                                          &id);
 
     let ctx = @core::DocContext {
         krate: krate,
diff --git a/src/libsemver/lib.rs b/src/libsemver/lib.rs
index cfdd388c0fa..6cbfeee6aa7 100644
--- a/src/libsemver/lib.rs
+++ b/src/libsemver/lib.rs
@@ -170,7 +170,6 @@ fn take_nonempty_prefix<T:Iterator<char>>(rdr: &mut T, pred: |char| -> bool)
             }
         }
     }
-    debug!("extracted nonempty prefix: {}", buf);
     (buf, ch)
 }
 
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 89e1e23637f..c27c5542ce1 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -23,7 +23,7 @@ Core encoding and decoding interfaces.
       html_root_url = "http://static.rust-lang.org/doc/master")];
 #[allow(missing_doc)];
 #[forbid(non_camel_case_types)];
-#[feature(macro_rules, managed_boxes, default_type_params)];
+#[feature(macro_rules, managed_boxes, default_type_params, phase)];
 
 // NOTE remove the following two attributes after the next snapshot.
 #[allow(unrecognized_lint)];
@@ -33,6 +33,8 @@ Core encoding and decoding interfaces.
 // test harness access
 #[cfg(test)]
 extern crate test;
+#[phase(syntax, link)]
+extern crate log;
 
 extern crate collections;
 
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 39c7932cdc8..243f7b2055f 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -97,6 +97,6 @@ pub unsafe fn annihilate() {
 
     if debug_mem() {
         // We do logging here w/o allocation.
-        debug!("total boxes annihilated: {}", n_total_boxes);
+        println!("total boxes annihilated: {}", n_total_boxes);
     }
 }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 28f6d13070e..c18d4e273c4 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -352,9 +352,7 @@ pub trait Reader {
         let mut buf = [0];
         loop {
             match self.read(buf) {
-                Ok(0) => {
-                    debug!("read 0 bytes. trying again");
-                }
+                Ok(0) => {}
                 Ok(1) => return Ok(buf[0]),
                 Ok(_) => unreachable!(),
                 Err(e) => return Err(e)
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index a3e5bac89d6..9eeaf4635a4 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -176,16 +176,14 @@ mod darwin_fd_limit {
         if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size,
                   mut_null(), 0) != 0 {
             let err = last_os_error();
-            error!("raise_fd_limit: error calling sysctl: {}", err);
-            return;
+            fail!("raise_fd_limit: error calling sysctl: {}", err);
         }
 
         // Fetch the current resource limits
         let mut rlim = rlimit{rlim_cur: 0, rlim_max: 0};
         if getrlimit(RLIMIT_NOFILE, &mut rlim) != 0 {
             let err = last_os_error();
-            error!("raise_fd_limit: error calling getrlimit: {}", err);
-            return;
+            fail!("raise_fd_limit: error calling getrlimit: {}", err);
         }
 
         // Bump the soft limit to the smaller of kern.maxfilesperproc and the hard limit
@@ -194,8 +192,7 @@ mod darwin_fd_limit {
         // Set our newly-increased resource limit
         if setrlimit(RLIMIT_NOFILE, &rlim) != 0 {
             let err = last_os_error();
-            error!("raise_fd_limit: error calling setrlimit: {}", err);
-            return;
+            fail!("raise_fd_limit: error calling setrlimit: {}", err);
         }
     }
 }
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 6bcac425420..9e988eb4094 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -398,9 +398,9 @@ pub trait Iterator<A> {
     /// let xs = [1u, 4, 2, 3, 8, 9, 6];
     /// let sum = xs.iter()
     ///             .map(|&x| x)
-    ///             .inspect(|&x| debug!("filtering {}", x))
+    ///             .inspect(|&x| println!("filtering {}", x))
     ///             .filter(|&x| x % 2 == 0)
-    ///             .inspect(|&x| debug!("{} made it through", x))
+    ///             .inspect(|&x| println!("{} made it through", x))
     ///             .sum();
     /// println!("{}", sum);
     /// ```
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 6b1773ec7ff..17c0e2235c0 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -53,7 +53,7 @@
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
 #[feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args,
-          simd, linkage, default_type_params)];
+          simd, linkage, default_type_params, phase)];
 
 // NOTE remove the following two attributes after the next snapshot.
 #[allow(unrecognized_lint)];
@@ -73,6 +73,7 @@
 #[cfg(test)] extern crate rustuv;
 #[cfg(test)] extern crate native;
 #[cfg(test)] extern crate green;
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 // Make and rand accessible for benchmarking/testcases
 #[cfg(test)] extern crate rand;
@@ -178,7 +179,6 @@ pub mod path;
 pub mod cast;
 pub mod fmt;
 pub mod cleanup;
-pub mod logging;
 pub mod mem;
 
 
@@ -221,7 +221,6 @@ mod std {
     pub use io;
     pub use kinds;
     pub use local_data;
-    pub use logging;
     pub use option;
     pub use os;
     pub use rt;
diff --git a/src/libstd/logging.rs b/src/libstd/logging.rs
deleted file mode 100644
index 2271a7c2380..00000000000
--- a/src/libstd/logging.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
-
-Utilities for program-wide and customizable logging
-
-This module is used by the compiler when emitting output for the logging family
-of macros. The methods of this module shouldn't necessarily be used directly,
-but rather through the logging macros defined.
-
-There are five macros that the logging subsystem uses:
-
-* `log!(level, ...)` - the generic logging macro, takes a level as a u32 and any
-                       related `format!` arguments
-* `debug!(...)` - a macro hard-wired to the log level of `DEBUG`
-* `info!(...)` - a macro hard-wired to the log level of `INFO`
-* `warn!(...)` - a macro hard-wired to the log level of `WARN`
-* `error!(...)` - a macro hard-wired to the log level of `ERROR`
-
-All of these macros use the same style of syntax as the `format!` syntax
-extension. Details about the syntax can be found in the documentation of
-`std::fmt` along with the Rust tutorial/manual.
-
-If you want to check at runtime if a given logging level is enabled (e.g. if the
-information you would want to log is expensive to produce), you can use the
-following macro:
-
-* `log_enabled!(level)` - returns true if logging of the given level is enabled
-
-## Enabling logging
-
-Log levels are controlled on a per-module basis, and by default all logging is
-disabled except for `error!` (a log level of 1). Logging is controlled via the
-`RUST_LOG` environment variable. The value of this environment variable is a
-comma-separated list of logging directives. A logging directive is of the form:
-
-```ignore
-path::to::module=log_level
-```
-
-The path to the module is rooted in the name of the crate it was compiled for,
-so if your program is contained in a file `hello.rs`, for example, to turn on
-logging for this file you would use a value of `RUST_LOG=hello`. Furthermore,
-this path is a prefix-search, so all modules nested in the specified module will
-also have logging enabled.
-
-The actual `log_level` is optional to specify. If omitted, all logging will be
-enabled. If specified, the it must be either a numeric in the range of 1-255, or
-it must be one of the strings `debug`, `error`, `info`, or `warn`. If a numeric
-is specified, then all logging less than or equal to that numeral is enabled.
-For example, if logging level 3 is active, error, warn, and info logs will be
-printed, but debug will be omitted.
-
-As the log level for a module is optional, the module to enable logging for is
-also optional. If only a `log_level` is provided, then the global log level for
-all modules is set to this value.
-
-Some examples of valid values of `RUST_LOG` are:
-
-```ignore
-hello                // turns on all logging for the 'hello' module
-info                 // turns on all info logging
-hello=debug          // turns on debug logging for 'hello'
-hello=3              // turns on info logging for 'hello'
-hello,std::option    // turns on hello, and std's option logging
-error,hello=warn     // turn on global error logging and also warn for hello
-```
-
-## Performance and Side Effects
-
-Each of these macros will expand to code similar to:
-
-```rust,ignore
-if log_level <= my_module_log_level() {
-    ::std::logging::log(log_level, format!(...));
-}
-```
-
-What this means is that each of these macros are very cheap at runtime if
-they're turned off (just a load and an integer comparison). This also means that
-if logging is disabled, none of the components of the log will be executed.
-
-## Useful Values
-
-For convenience, if a value of `::help` is set for `RUST_LOG`, a program will
-start, print out all modules registered for logging, and then exit.
-
-*/
-
-use fmt;
-use io::LineBufferedWriter;
-use io;
-use io::Writer;
-use mem::replace;
-use ops::Drop;
-use option::{Some, None, Option};
-use prelude::drop;
-use result::{Ok, Err};
-use rt::local::Local;
-use rt::task::Task;
-
-/// Debug log level
-pub static DEBUG: u32 = 4;
-/// Info log level
-pub static INFO: u32 = 3;
-/// Warn log level
-pub static WARN: u32 = 2;
-/// Error log level
-pub static ERROR: u32 = 1;
-
-/// A trait used to represent an interface to a task-local logger. Each task
-/// can have its own custom logger which can respond to logging messages
-/// however it likes.
-pub trait Logger {
-    /// Logs a single message described by the `args` structure. The level is
-    /// provided in case you want to do things like color the message, etc.
-    fn log(&mut self, level: u32, args: &fmt::Arguments);
-}
-
-struct DefaultLogger {
-    handle: LineBufferedWriter<io::stdio::StdWriter>,
-}
-
-impl Logger for DefaultLogger {
-    // by default, just ignore the level
-    fn log(&mut self, _level: u32, args: &fmt::Arguments) {
-        match fmt::writeln(&mut self.handle, args) {
-            Err(e) => fail!("failed to log: {}", e),
-            Ok(()) => {}
-        }
-    }
-}
-
-impl Drop for DefaultLogger {
-    fn drop(&mut self) {
-        match self.handle.flush() {
-            Err(e) => fail!("failed to flush a logger: {}", e),
-            Ok(()) => {}
-        }
-    }
-}
-
-/// This function is called directly by the compiler when using the logging
-/// macros. This function does not take into account whether the log level
-/// specified is active or not, it will always log something if this method is
-/// called.
-///
-/// It is not recommended to call this function directly, rather it should be
-/// invoked through the logging family of macros.
-pub fn log(level: u32, args: &fmt::Arguments) {
-    // See io::stdio::with_task_stdout for why there's a few dances here. The
-    // gist of it is that arbitrary code can run during logging (and set an
-    // arbitrary logging handle into the task) so we need to be careful that the
-    // local task is in TLS while we're running arbitrary code.
-    let mut logger = {
-        let mut task = Local::borrow(None::<Task>);
-        task.get().logger.take()
-    };
-
-    if logger.is_none() {
-        logger = Some(~DefaultLogger { handle: io::stderr(), } as ~Logger);
-    }
-    logger.get_mut_ref().log(level, args);
-
-    let mut task = Local::borrow(None::<Task>);
-    let prev = replace(&mut task.get().logger, logger);
-    drop(task);
-    drop(prev);
-}
-
-/// Replaces the task-local logger with the specified logger, returning the old
-/// logger.
-pub fn set_logger(logger: ~Logger) -> Option<~Logger> {
-    let mut task = Local::borrow(None::<Task>);
-    replace(&mut task.get().logger, Some(logger))
-}
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index ece9c1bfd20..6d96ea94d31 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -16,107 +16,6 @@
 
 #[macro_escape];
 
-/// The standard logging macro
-///
-/// This macro will generically log over a provided level (of type u32) with a
-/// format!-based argument list. See documentation in `std::fmt` for details on
-/// how to use the syntax, and documentation in `std::logging` for info about
-/// logging macros.
-///
-/// # Example
-///
-/// ```
-/// log!(::std::logging::DEBUG, "this is a debug message");
-/// log!(::std::logging::WARN, "this is a warning {}", "message");
-/// log!(6, "this is a custom logging level: {level}", level=6);
-/// ```
-#[macro_export]
-macro_rules! log(
-    ($lvl:expr, $($arg:tt)+) => ({
-        let lvl = $lvl;
-        if lvl <= __log_level() {
-            format_args!(|args| {
-                ::std::logging::log(lvl, args)
-            }, $($arg)+)
-        }
-    })
-)
-
-/// A convenience macro for logging at the error log level. See `std::logging`
-/// for more information. about logging.
-///
-/// # Example
-///
-/// ```
-/// # let error = 3;
-/// error!("the build has failed with error code: {}", error);
-/// ```
-#[macro_export]
-macro_rules! error(
-    ($($arg:tt)*) => (log!(1u32, $($arg)*))
-)
-
-/// A convenience macro for logging at the warning log level. See `std::logging`
-/// for more information. about logging.
-///
-/// # Example
-///
-/// ```
-/// # let code = 3;
-/// warn!("you may like to know that a process exited with: {}", code);
-/// ```
-#[macro_export]
-macro_rules! warn(
-    ($($arg:tt)*) => (log!(2u32, $($arg)*))
-)
-
-/// A convenience macro for logging at the info log level. See `std::logging`
-/// for more information. about logging.
-///
-/// # Example
-///
-/// ```
-/// # let ret = 3;
-/// info!("this function is about to return: {}", ret);
-/// ```
-#[macro_export]
-macro_rules! info(
-    ($($arg:tt)*) => (log!(3u32, $($arg)*))
-)
-
-/// A convenience macro for logging at the debug log level. See `std::logging`
-/// for more information. about logging.
-///
-/// # Example
-///
-/// ```
-/// debug!("x = {x}, y = {y}", x=10, y=20);
-/// ```
-#[macro_export]
-macro_rules! debug(
-    ($($arg:tt)*) => (if cfg!(not(ndebug)) { log!(4u32, $($arg)*) })
-)
-
-/// A macro to test whether a log level is enabled for the current module.
-///
-/// # Example
-///
-/// ```
-/// # struct Point { x: int, y: int }
-/// # fn some_expensive_computation() -> Point { Point { x: 1, y: 2 } }
-/// if log_enabled!(std::logging::DEBUG) {
-///     let x = some_expensive_computation();
-///     debug!("x.x = {}, x.y = {}", x.x, x.y);
-/// }
-/// ```
-#[macro_export]
-macro_rules! log_enabled(
-    ($lvl:expr) => ({
-        let lvl = $lvl;
-        lvl <= __log_level() && (lvl != 4 || cfg!(not(ndebug)))
-    })
-)
-
 /// The entry point for failure of rust tasks.
 ///
 /// This macro is used to inject failure into a rust task, causing the task to
@@ -421,3 +320,15 @@ macro_rules! select {
         { unreachable!() }
     })
 }
+
+// When testing the standard library, we link to the liblog crate to get the
+// logging macros. In doing so, the liblog crate was linked against the real
+// version of libstd, and uses a different std::fmt module than the test crate
+// uses. To get around this difference, we redefine the log!() macro here to be
+// just a dumb version of what it should be.
+#[cfg(test)]
+macro_rules! log (
+    ($lvl:expr, $($args:tt)*) => (
+        if log_enabled!($lvl) { println!($($args)*) }
+    )
+)
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index b8f00d1b692..0c46a501299 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -1127,14 +1127,8 @@ impl Drop for MemoryMap {
         if self.len == 0 { /* workaround for dummy_stack */ return; }
 
         unsafe {
-            match libc::munmap(self.data as *c_void, self.len as libc::size_t) {
-                0 => (),
-                -1 => match errno() as c_int {
-                    libc::EINVAL => error!("invalid addr or len"),
-                    e => error!("unknown errno={}", e)
-                },
-                r => error!("Unexpected result {}", r)
-            }
+            // FIXME: what to do if this fails?
+            let _ = libc::munmap(self.data as *c_void, self.len as libc::size_t);
         }
     }
 }
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 95eda1cecc0..bf5ba6db5c3 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -163,7 +163,6 @@ pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
   SAFETY NOTE: Pointer-arithmetic. Dragons be here.
 */
 pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
-    debug!("array_each_with_len: before iterate");
     if arr.is_null() {
         fail!("ptr::array_each_with_len failure: arr input is null pointer");
     }
@@ -172,7 +171,6 @@ pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
         let n = arr.offset(e as int);
         cb(*n);
     }
-    debug!("array_each_with_len: after iterate");
 }
 
 /**
@@ -189,7 +187,6 @@ pub unsafe fn array_each<T>(arr: **T, cb: |*T|) {
         fail!("ptr::array_each_with_len failure: arr input is null pointer");
     }
     let len = buf_len(arr);
-    debug!("array_each inferred len: {}", len);
     array_each_with_len(arr, len, cb);
 }
 
diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs
deleted file mode 100644
index aa024a53b89..00000000000
--- a/src/libstd/rt/logging.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use container::Container;
-use from_str::from_str;
-use iter::Iterator;
-use libc::exit;
-use option::{Some, None, Option};
-use os;
-use rt::crate_map::{ModEntry, CrateMap, iter_crate_map, get_crate_map};
-use str::{Str, StrSlice};
-use vec::{ImmutableVector, MutableTotalOrdVector, OwnedVector};
-use vec_ng::Vec;
-
-struct LogDirective<'a> {
-    name: Option<&'a str>,
-    level: u32
-}
-
-static MAX_LOG_LEVEL: u32 = 255;
-static DEFAULT_LOG_LEVEL: u32 = 1;
-static log_level_names : &'static[&'static str] = &'static["error", "warn", "info", "debug"];
-
-/// Parse an individual log level that is either a number or a symbolic log level
-fn parse_log_level(level: &str) -> Option<u32> {
-    let num = from_str::<u32>(level);
-    let mut log_level;
-    match num {
-        Some(num) => {
-            if num < MAX_LOG_LEVEL {
-                log_level = Some(num);
-            } else {
-                log_level = Some(MAX_LOG_LEVEL);
-            }
-        }
-        _ => {
-            let position = log_level_names.iter().position(|&name| name == level);
-            match position {
-                Some(position) => {
-                    log_level = Some(::cmp::min(MAX_LOG_LEVEL, (position + 1) as u32))
-                },
-                _ => {
-                    log_level = None;
-                }
-            }
-        }
-    }
-    log_level
-}
-
-/// Parse a logging specification string (e.g: "crate1,crate2::mod3,crate3::x=1")
-/// and return a vector with log directives.
-/// Valid log levels are 0-255, with the most likely ones being 1-4 (defined in std::).
-/// Also supports string log levels of error, warn, info, and debug
-fn parse_logging_spec<'a>(spec: &'a str) -> Vec<LogDirective<'a>> {
-    let mut dirs = Vec::new();
-    for s in spec.split(',') {
-        if s.len() == 0 { continue }
-        let mut parts = s.split('=');
-        let log_level;
-        let name;
-        match (parts.next(), parts.next(), parts.next()) {
-            (Some(part0), None, None) => {
-                //if the single argument is a log-level string or number,
-                //treat that as a global fallback
-                let possible_log_level = parse_log_level(part0);
-                match possible_log_level {
-                    Some(num) => {
-                        name = None;
-                        log_level = num;
-                    },
-                    None => {
-                        log_level = MAX_LOG_LEVEL;
-                        name = Some(part0);
-                    }
-                }
-            }
-            (Some(part0), Some(part1), None) => {
-                let possible_log_level = parse_log_level(part1);
-                match possible_log_level {
-                    Some(num) => {
-                        name = Some(part0);
-                        log_level = num;
-                    },
-                    _ => {
-                        rterrln!("warning: invalid logging spec '{}', \
-                                  ignoring it", part1);
-                        continue
-                    }
-                }
-            },
-            _ => {
-                rterrln!("warning: invalid logging spec '{}', \
-                          ignoring it", s);
-                continue
-            }
-        }
-        dirs.push(LogDirective { name: name, level: log_level });
-    }
-    return dirs;
-}
-
-/// Set the log level of an entry in the crate map depending on the vector
-/// of log directives
-fn update_entry(dirs: &[LogDirective], entry: &ModEntry) -> u32 {
-    let mut new_lvl: u32 = DEFAULT_LOG_LEVEL;
-    let mut longest_match = -1i;
-    for dir in dirs.iter() {
-        match dir.name {
-            None => {
-                if longest_match == -1 {
-                    longest_match = 0;
-                    new_lvl = dir.level;
-                }
-            }
-            Some(ref dir_name) => {
-                let name = entry.name;
-                let len = dir_name.len() as int;
-                if name.starts_with(*dir_name) &&
-                    len >= longest_match {
-                    longest_match = len;
-                    new_lvl = dir.level;
-                }
-            }
-        };
-    }
-    unsafe { *entry.log_level = new_lvl; }
-    if longest_match >= 0 { return 1; } else { return 0; }
-}
-
-/// Set log level for every entry in crate_map according to the sepecification
-/// in settings
-fn update_log_settings(crate_map: &CrateMap, settings: &str) {
-    if settings == "::help" || settings == "?" {
-        rterrln!("\nCrate log map:\n");
-
-        let mut entries = Vec::new();
-        iter_crate_map(crate_map, |entry| entries.push(entry.name));
-        entries.as_mut_slice().sort();
-
-        for name in entries.iter() {
-            rterrln!(" {}", *name);
-        }
-        unsafe { exit(1); }
-    }
-    let dirs = parse_logging_spec(settings);
-
-    let mut n_matches: u32 = 0;
-    iter_crate_map(crate_map, |entry| {
-        let m = update_entry(dirs.as_slice(), entry);
-        n_matches += m;
-    });
-
-    if n_matches < (dirs.len() as u32) {
-        rterrln!("warning: got {} RUST_LOG specs but only matched\n\
-                  {} of them. You may have mistyped a RUST_LOG spec. \n\
-                  Use RUST_LOG=::help to see the list of crates and modules.\n",
-                 dirs.len(), n_matches);
-    }
-}
-
-/// Configure logging by traversing the crate map and setting the
-/// per-module global logging flags based on the logging spec
-pub fn init() {
-    let log_spec = os::getenv("RUST_LOG");
-    match get_crate_map() {
-        Some(crate_map) => {
-            match log_spec {
-                Some(spec) => update_log_settings(crate_map, spec.as_slice()),
-                None => update_log_settings(crate_map, ""),
-            }
-        },
-        _ => {
-            match log_spec {
-                Some(_) => {
-                    rterrln!("warning: RUST_LOG set, but no crate map found.");
-                },
-                None => {}
-            }
-        }
-    }
-}
-
-// Tests for parse_logging_spec()
-#[test]
-fn parse_logging_spec_valid() {
-    let dirs = parse_logging_spec("crate1::mod1=1,crate1::mod2,crate2=4");
-    let dirs = dirs.as_slice();
-    assert_eq!(dirs.len(), 3);
-    assert_eq!(dirs[0].name, Some("crate1::mod1"));
-    assert_eq!(dirs[0].level, 1);
-
-    assert_eq!(dirs[1].name, Some("crate1::mod2"));
-    assert_eq!(dirs[1].level, MAX_LOG_LEVEL);
-
-    assert_eq!(dirs[2].name, Some("crate2"));
-    assert_eq!(dirs[2].level, 4);
-}
-
-#[test]
-fn parse_logging_spec_invalid_crate() {
-    // test parse_logging_spec with multiple = in specification
-    let dirs = parse_logging_spec("crate1::mod1=1=2,crate2=4");
-    let dirs = dirs.as_slice();
-    assert_eq!(dirs.len(), 1);
-    assert_eq!(dirs[0].name, Some("crate2"));
-    assert_eq!(dirs[0].level, 4);
-}
-
-#[test]
-fn parse_logging_spec_invalid_log_level() {
-    // test parse_logging_spec with 'noNumber' as log level
-    let dirs = parse_logging_spec("crate1::mod1=noNumber,crate2=4");
-    let dirs = dirs.as_slice();
-    assert_eq!(dirs.len(), 1);
-    assert_eq!(dirs[0].name, Some("crate2"));
-    assert_eq!(dirs[0].level, 4);
-}
-
-#[test]
-fn parse_logging_spec_string_log_level() {
-    // test parse_logging_spec with 'warn' as log level
-    let dirs = parse_logging_spec("crate1::mod1=wrong,crate2=warn");
-    let dirs = dirs.as_slice();
-    assert_eq!(dirs.len(), 1);
-    assert_eq!(dirs[0].name, Some("crate2"));
-    assert_eq!(dirs[0].level, 2);
-}
-
-#[test]
-fn parse_logging_spec_global() {
-    // test parse_logging_spec with no crate
-    let dirs = parse_logging_spec("warn,crate2=4");
-    let dirs = dirs.as_slice();
-    assert_eq!(dirs.len(), 2);
-    assert_eq!(dirs[0].name, None);
-    assert_eq!(dirs[0].level, 2);
-    assert_eq!(dirs[1].name, Some("crate2"));
-    assert_eq!(dirs[1].level, 4);
-}
-
-// Tests for update_entry
-#[test]
-fn update_entry_match_full_path() {
-    let dirs = [LogDirective { name: Some("crate1::mod1"), level: 2 },
-                LogDirective { name: Some("crate2"), level: 3 }];
-    let mut level = 0;
-    {
-        let entry = &ModEntry { name: "crate1::mod1", log_level: &mut level };
-        assert_eq!(update_entry(dirs, entry), 1);
-    }
-    assert_eq!(level, 2);
-}
-
-#[test]
-fn update_entry_no_match() {
-    let dirs = [LogDirective { name: Some("crate1::mod1"), level: 2 },
-                LogDirective { name: Some("crate2"), level: 3 }];
-    let mut level = 0;
-    {
-        let entry = &ModEntry { name: "crate3::mod1", log_level: &mut level };
-        assert_eq!(update_entry(dirs, entry), 0);
-    }
-    assert_eq!(level, DEFAULT_LOG_LEVEL);
-}
-
-#[test]
-fn update_entry_match_beginning() {
-    let dirs = [LogDirective { name: Some("crate1::mod1"), level: 2 },
-                LogDirective { name: Some("crate2"), level: 3 }];
-    let mut level = 0;
-    {
-        let entry= &ModEntry {name: "crate2::mod1", log_level: &mut level};
-        assert_eq!(update_entry(dirs, entry), 1);
-    }
-    assert_eq!(level, 3);
-}
-
-#[test]
-fn update_entry_match_beginning_longest_match() {
-    let dirs = [LogDirective { name: Some("crate1::mod1"), level: 2 },
-                LogDirective { name: Some("crate2"), level: 3 },
-                LogDirective { name: Some("crate2::mod"), level: 4 }];
-    let mut level = 0;
-    {
-        let entry = &ModEntry { name: "crate2::mod1", log_level: &mut level };
-        assert_eq!(update_entry(dirs, entry), 1);
-    }
-    assert_eq!(level, 4);
-}
-
-#[test]
-fn update_entry_match_default() {
-    let dirs = [LogDirective { name: Some("crate1::mod1"), level: 2 },
-                LogDirective { name: None, level: 3 }];
-    let mut level = 0;
-    {
-        let entry = &ModEntry { name: "crate1::mod1", log_level: &mut level };
-        assert_eq!(update_entry(dirs, entry), 1);
-    }
-    assert_eq!(level, 2);
-    {
-        let entry = &ModEntry { name: "crate2::mod2", log_level: &mut level };
-        assert_eq!(update_entry(dirs, entry), 1);
-    }
-    assert_eq!(level, 3);
-}
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index a58826daa49..84e547619df 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -104,9 +104,6 @@ pub mod env;
 /// The local, managed heap
 pub mod local_heap;
 
-/// The Logger trait and implementations
-pub mod logging;
-
 /// Crate map
 pub mod crate_map;
 
@@ -183,7 +180,6 @@ pub fn init(argc: int, argv: **u8) {
     unsafe {
         args::init(argc, argv);
         env::init();
-        logging::init();
         local_ptr::init();
         at_exit_imp::init();
     }
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 86e69560e9d..8c617c1b59b 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -21,7 +21,6 @@ use comm::Sender;
 use io::Writer;
 use iter::{Iterator, Take};
 use local_data;
-use logging::Logger;
 use ops::Drop;
 use option::{Option, Some, None};
 use prelude::drop;
@@ -51,7 +50,6 @@ pub struct Task {
     destroyed: bool,
     name: Option<SendStr>,
 
-    logger: Option<~Logger>,
     stdout: Option<~Writer>,
     stderr: Option<~Writer>,
 
@@ -95,7 +93,6 @@ impl Task {
             death: Death::new(),
             destroyed: false,
             name: None,
-            logger: None,
             stdout: None,
             stderr: None,
             imp: None,
@@ -129,11 +126,9 @@ impl Task {
                 #[allow(unused_must_use)]
                 fn close_outputs() {
                     let mut task = Local::borrow(None::<Task>);
-                    let logger = task.get().logger.take();
                     let stderr = task.get().stderr.take();
                     let stdout = task.get().stdout.take();
                     drop(task);
-                    drop(logger); // loggers are responsible for flushing
                     match stdout { Some(mut w) => { w.flush(); }, None => {} }
                     match stderr { Some(mut w) => { w.flush(); }, None => {} }
                 }
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index 19f41c6fa1c..9c88db6beb5 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -40,7 +40,6 @@ use any::Any;
 use comm::{Sender, Receiver, channel};
 use io::Writer;
 use kinds::{Send, marker};
-use logging::Logger;
 use option::{None, Some, Option};
 use result::{Result, Ok, Err};
 use rt::local::Local;
@@ -66,8 +65,6 @@ pub struct TaskOpts {
     name: Option<SendStr>,
     /// The size of the stack for the spawned task
     stack_size: Option<uint>,
-    /// Task-local logger (see std::logging)
-    logger: Option<~Logger>,
     /// Task-local stdout
     stdout: Option<~Writer>,
     /// Task-local stderr
@@ -230,7 +227,6 @@ impl TaskOpts {
             notify_chan: None,
             name: None,
             stack_size: None,
-            logger: None,
             stdout: None,
             stderr: None,
         }
diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs
index bab1a00e5ac..924af6bfd42 100644
--- a/src/libsync/lib.rs
+++ b/src/libsync/lib.rs
@@ -19,6 +19,9 @@
 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
+#[feature(phase)];
+
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 #[allow(deprecated_owned_vector)];
 
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 56a99736866..f7983933990 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -18,7 +18,6 @@ use parse::token;
 use print::pprust;
 use util::small_vector::SmallVector;
 
-use std::logging;
 use std::cell::RefCell;
 use std::iter;
 use std::vec;
@@ -538,7 +537,7 @@ pub fn map_crate<F: FoldOps>(krate: Crate, fold_ops: F) -> (Crate, Map) {
         cx.fold_crate(krate)
     };
 
-    if log_enabled!(logging::DEBUG) {
+    if log_enabled!(::log::DEBUG) {
         let map = map.map.borrow();
         // This only makes sense for ordered stores; note the
         // enumerate to count the number of entries.
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index ae8c13a5f98..b575cfaade6 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -339,7 +339,12 @@ impl<'a> ExtCtxt<'a> {
     pub fn backtrace(&self) -> Option<@ExpnInfo> { self.backtrace }
     pub fn mod_push(&mut self, i: ast::Ident) { self.mod_path.push(i); }
     pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); }
-    pub fn mod_path(&self) -> Vec<ast::Ident> { self.mod_path.clone() }
+    pub fn mod_path(&self) -> Vec<ast::Ident> {
+        let mut v = Vec::new();
+        v.push(token::str_to_ident(self.ecfg.crate_id.name));
+        v.extend(&mut self.mod_path.iter().map(|a| *a));
+        return v;
+    }
     pub fn bt_push(&mut self, ei: codemap::ExpnInfo) {
         match ei {
             ExpnInfo {call_site: cs, callee: ref callee} => {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index dc79ceb4daa..c24894af3be 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -19,6 +19,7 @@ use attr;
 use attr::AttrMetaMethods;
 use codemap;
 use codemap::{Span, Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute};
+use crateid::CrateId;
 use ext::base::*;
 use fold::*;
 use parse;
@@ -871,6 +872,7 @@ impl<'a> Folder for MacroExpander<'a> {
 pub struct ExpansionConfig<'a> {
     loader: &'a mut CrateLoader,
     deriving_hash_type_parameter: bool,
+    crate_id: CrateId,
 }
 
 pub fn expand_crate(parse_sess: @parse::ParseSess,
@@ -1048,6 +1050,7 @@ mod test {
         let cfg = ::syntax::ext::expand::ExpansionConfig {
             loader: &mut loader,
             deriving_hash_type_parameter: false,
+            crate_id: from_str("test").unwrap(),
         };
         expand_crate(sess,cfg,crate_ast);
     }
@@ -1067,6 +1070,7 @@ mod test {
         let cfg = ::syntax::ext::expand::ExpansionConfig {
             loader: &mut loader,
             deriving_hash_type_parameter: false,
+            crate_id: from_str("test").unwrap(),
         };
         expand_crate(sess,cfg,crate_ast);
     }
@@ -1085,6 +1089,7 @@ mod test {
         let cfg = ::syntax::ext::expand::ExpansionConfig {
             loader: &mut loader,
             deriving_hash_type_parameter: false,
+            crate_id: from_str("test").unwrap(),
         };
         expand_crate(sess, cfg, crate_ast);
     }
@@ -1127,6 +1132,7 @@ mod test {
         let cfg = ::syntax::ext::expand::ExpansionConfig {
             loader: &mut loader,
             deriving_hash_type_parameter: false,
+            crate_id: from_str("test").unwrap(),
         };
         expand_crate(ps,cfg,crate_ast)
     }
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index e84d43117e5..08b4fa7b444 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -26,9 +26,7 @@ This API is completely unstable and subject to change.
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
-#[feature(macro_rules, globs, managed_boxes, default_type_params)];
-#[allow(unknown_features)];// Note: remove it after a snapshot.
-#[feature(quote)];
+#[feature(macro_rules, globs, managed_boxes, default_type_params, phase, quote)];
 
 #[allow(deprecated)];
 #[deny(non_camel_case_types)];
@@ -37,6 +35,8 @@ This API is completely unstable and subject to change.
 extern crate serialize;
 extern crate term;
 extern crate collections;
+#[phase(syntax, link)]
+extern crate log;
 
 pub mod util {
     pub mod interner;
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index cd52ff4b0ac..efadea16fe2 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -462,41 +462,40 @@ declare_special_idents_and_keywords! {
         (20,                         Impl,       "impl");
         (21,                         In,         "in");
         (22,                         Let,        "let");
-        (23,                         __LogLevel, "__log_level");
-        (24,                         Loop,       "loop");
-        (25,                         Match,      "match");
-        (26,                         Mod,        "mod");
-        (27,                         Mut,        "mut");
-        (28,                         Once,       "once");
-        (29,                         Priv,       "priv");
-        (30,                         Pub,        "pub");
-        (31,                         Ref,        "ref");
-        (32,                         Return,     "return");
+        (23,                         Loop,       "loop");
+        (24,                         Match,      "match");
+        (25,                         Mod,        "mod");
+        (26,                         Mut,        "mut");
+        (27,                         Once,       "once");
+        (28,                         Priv,       "priv");
+        (29,                         Pub,        "pub");
+        (30,                         Ref,        "ref");
+        (31,                         Return,     "return");
         // Static and Self are also special idents (prefill de-dupes)
         (super::STATIC_KEYWORD_NAME, Static,     "static");
         (super::SELF_KEYWORD_NAME,   Self,       "self");
-        (33,                         Struct,     "struct");
-        (34,                         Super,      "super");
-        (35,                         True,       "true");
-        (36,                         Trait,      "trait");
-        (37,                         Type,       "type");
-        (38,                         Unsafe,     "unsafe");
-        (39,                         Use,        "use");
-        (40,                         While,      "while");
-        (41,                         Continue,   "continue");
-        (42,                         Proc,       "proc");
-        (43,                         Box,        "box");
+        (32,                         Struct,     "struct");
+        (33,                         Super,      "super");
+        (34,                         True,       "true");
+        (35,                         Trait,      "trait");
+        (36,                         Type,       "type");
+        (37,                         Unsafe,     "unsafe");
+        (38,                         Use,        "use");
+        (39,                         While,      "while");
+        (40,                         Continue,   "continue");
+        (41,                         Proc,       "proc");
+        (42,                         Box,        "box");
 
         'reserved:
-        (44,                         Alignof,    "alignof");
-        (45,                         Be,         "be");
-        (46,                         Offsetof,   "offsetof");
-        (47,                         Pure,       "pure");
-        (48,                         Sizeof,     "sizeof");
-        (49,                         Typeof,     "typeof");
-        (50,                         Unsized,    "unsized");
-        (51,                         Yield,      "yield");
-        (52,                         Do,         "do");
+        (43,                         Alignof,    "alignof");
+        (44,                         Be,         "be");
+        (45,                         Offsetof,   "offsetof");
+        (46,                         Pure,       "pure");
+        (47,                         Sizeof,     "sizeof");
+        (48,                         Typeof,     "typeof");
+        (49,                         Unsized,    "unsized");
+        (50,                         Yield,      "yield");
+        (51,                         Do,         "do");
     }
 }
 
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index ca142ab8697..089c1668bf3 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -156,8 +156,6 @@ impl<T: Writer> Terminal<T> {
             if s.is_ok() {
                 try!(self.out.write(s.unwrap()));
                 return Ok(true)
-            } else {
-                warn!("{}", s.unwrap_err());
             }
         }
         Ok(false)
@@ -177,8 +175,6 @@ impl<T: Writer> Terminal<T> {
             if s.is_ok() {
                 try!(self.out.write(s.unwrap()));
                 return Ok(true)
-            } else {
-                warn!("{}", s.unwrap_err());
             }
         }
         Ok(false)
@@ -199,8 +195,6 @@ impl<T: Writer> Terminal<T> {
                     if s.is_ok() {
                         try!(self.out.write(s.unwrap()));
                         return Ok(true)
-                    } else {
-                        warn!("{}", s.unwrap_err());
                     }
                 }
                 Ok(false)
@@ -237,12 +231,6 @@ impl<T: Writer> Terminal<T> {
         });
         if s.is_ok() {
             return self.out.write(s.unwrap())
-        } else if self.num_colors > 0 {
-            warn!("{}", s.unwrap_err());
-        } else {
-            // if we support attributes but not color, it would be nice to still warn!()
-            // but it's not worth testing all known attributes just for this.
-            debug!("{}", s.unwrap_err());
         }
         Ok(())
     }
diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs
index e9d71d1c2f7..8ba3ad53121 100644
--- a/src/libterm/terminfo/parser/compiled.rs
+++ b/src/libterm/terminfo/parser/compiled.rs
@@ -195,27 +195,15 @@ pub fn parse(file: &mut io::Reader,
 
     assert!(names_bytes          > 0);
 
-    debug!("names_bytes = {}", names_bytes);
-    debug!("bools_bytes = {}", bools_bytes);
-    debug!("numbers_count = {}", numbers_count);
-    debug!("string_offsets_count = {}", string_offsets_count);
-    debug!("string_table_bytes = {}", string_table_bytes);
-
     if (bools_bytes as uint) > boolnames.len() {
-        error!("expected bools_bytes to be less than {} but found {}", boolnames.len(),
-               bools_bytes);
         return Err(~"incompatible file: more booleans than expected");
     }
 
     if (numbers_count as uint) > numnames.len() {
-        error!("expected numbers_count to be less than {} but found {}", numnames.len(),
-               numbers_count);
         return Err(~"incompatible file: more numbers than expected");
     }
 
     if (string_offsets_count as uint) > stringnames.len() {
-        error!("expected string_offsets_count to be less than {} but found {}", stringnames.len(),
-               string_offsets_count);
         return Err(~"incompatible file: more string offsets than expected");
     }
 
@@ -229,26 +217,19 @@ pub fn parse(file: &mut io::Reader,
 
     try!(file.read_byte()); // consume NUL
 
-    debug!("term names: {:?}", term_names);
-
     let mut bools_map = HashMap::new();
     if bools_bytes != 0 {
         for i in range(0, bools_bytes) {
             let b = try!(file.read_byte());
             if b < 0 {
-                error!("EOF reading bools after {} entries", i);
                 return Err(~"error: expected more bools but hit EOF");
             } else if b == 1 {
-                debug!("{} set", bnames[i]);
                 bools_map.insert(bnames[i].to_owned(), true);
             }
         }
     }
 
-    debug!("bools: {:?}", bools_map);
-
     if (bools_bytes + names_bytes) % 2 == 1 {
-        debug!("adjusting for padding between bools and numbers");
         try!(file.read_byte()); // compensate for padding
     }
 
@@ -257,14 +238,11 @@ pub fn parse(file: &mut io::Reader,
         for i in range(0, numbers_count) {
             let n = try!(file.read_le_u16());
             if n != 0xFFFF {
-                debug!("{}\\#{}", nnames[i], n);
                 numbers_map.insert(nnames[i].to_owned(), n);
             }
         }
     }
 
-    debug!("numbers: {:?}", numbers_map);
-
     let mut string_map = HashMap::new();
 
     if string_offsets_count != 0 {
@@ -273,13 +251,9 @@ pub fn parse(file: &mut io::Reader,
             string_offsets.push(try!(file.read_le_u16()));
         }
 
-        debug!("offsets: {:?}", string_offsets);
-
         let string_table = try!(file.read_bytes(string_table_bytes as uint));
 
         if string_table.len() != string_table_bytes as uint {
-            error!("EOF reading string table after {} bytes, wanted {}", string_table.len(),
-                   string_table_bytes);
             return Err(~"error: hit EOF before end of string table");
         }
 
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 4c7226a3880..efd1fbcd1ac 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -692,7 +692,6 @@ pub fn run_tests_console(opts: &TestOpts,
                          tests: ~[TestDescAndFn]) -> io::IoResult<bool> {
     fn callback<T: Writer>(event: &TestEvent,
                            st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
-        debug!("callback(event={:?})", event);
         match (*event).clone() {
             TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
             TeWait(ref test, padding) => st.write_test_start(test, padding),
@@ -736,7 +735,6 @@ pub fn run_tests_console(opts: &TestOpts,
     match tests.iter().max_by(|t|len_if_padded(*t)) {
         Some(t) => {
             let n = t.desc.name.to_str();
-            debug!("Setting max_name_len from: {}", n);
             st.max_name_len = n.len();
         },
         None => {}
@@ -825,7 +823,6 @@ fn run_tests(opts: &TestOpts,
     // It's tempting to just spawn all the tests at once, but since we have
     // many tests that run in other processes we would be making a big mess.
     let concurrency = get_concurrency();
-    debug!("using {} test tasks", concurrency);
 
     let mut remaining = filtered_tests;
     remaining.reverse();
@@ -1151,7 +1148,6 @@ impl MetricMap {
         });
 
         if ok {
-            debug!("rewriting file '{:?}' with updated metrics", p);
             self.save(p).unwrap();
         }
         return (diff, ok)
@@ -1202,8 +1198,6 @@ impl BenchHarness {
 
     pub fn bench_n(&mut self, n: u64, f: |&mut BenchHarness|) {
         self.iterations = n;
-        debug!("running benchmark for {} iterations",
-               n as uint);
         f(self);
     }
 
@@ -1228,9 +1222,6 @@ impl BenchHarness {
         // (i.e. larger error bars).
         if n == 0 { n = 1; }
 
-        debug!("Initial run took {} ns, iter count that takes 1ms estimated as {}",
-               self.ns_per_iter(), n);
-
         let mut total_run = 0;
         let samples : &mut [f64] = [0.0_f64, ..50];
         loop {
@@ -1252,12 +1243,6 @@ impl BenchHarness {
             stats::winsorize(samples, 5.0);
             let summ5 = stats::Summary::new(samples);
 
-            debug!("{} samples, median {}, MAD={}, MADP={}",
-                   samples.len(),
-                   summ.median as f64,
-                   summ.median_abs_dev as f64,
-                   summ.median_abs_dev_pct as f64);
-
             let now = precise_time_ns();
             let loop_run = now - loop_start;
 
diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs
index 8b496875c30..eb2b72cb630 100644
--- a/src/libtime/lib.rs
+++ b/src/libtime/lib.rs
@@ -16,9 +16,10 @@
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
-#[allow(missing_doc)];
+#[feature(phase)];
 #[allow(deprecated_owned_vector)];
 
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
 extern crate serialize;
 
 use std::io::BufReader;
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 98e5c8c2b5b..7479ddc3e57 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -21,11 +21,11 @@ pub mod kitties {
 
         pub fn eat(&mut self) -> bool {
             if self.how_hungry > 0 {
-                error!("OM NOM NOM");
+                println!("OM NOM NOM");
                 self.how_hungry -= 2;
                 return true;
             } else {
-                error!("Not hungry!");
+                println!("Not hungry!");
                 return false;
             }
         }
@@ -33,7 +33,7 @@ pub mod kitties {
 
     impl cat {
         pub fn meow(&mut self) {
-            error!("Meow");
+            println!("Meow");
             self.meows += 1u;
             if self.meows % 5u == 0u {
                 self.how_hungry += 1;
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index 79bb5aef764..e7e0e6d450a 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -25,7 +25,7 @@ pub mod kitty {
 
     impl cat {
         fn meow(&mut self) {
-            error!("Meow");
+            println!("Meow");
             self.meows += 1u;
             if self.meows % 5u == 0u {
                 self.how_hungry += 1;
@@ -39,12 +39,12 @@ pub mod kitty {
 
         pub fn eat(&mut self) -> bool {
             if self.how_hungry > 0 {
-                error!("OM NOM NOM");
+                println!("OM NOM NOM");
                 self.how_hungry -= 2;
                 return true;
             }
             else {
-                error!("Not hungry!");
+                println!("Not hungry!");
                 return false;
             }
         }
diff --git a/src/test/auxiliary/extern-crosscrate-source.rs b/src/test/auxiliary/extern-crosscrate-source.rs
index 72345022282..d2c79bbe9cb 100644
--- a/src/test/auxiliary/extern-crosscrate-source.rs
+++ b/src/test/auxiliary/extern-crosscrate-source.rs
@@ -26,7 +26,7 @@ pub mod rustrt {
 
 pub fn fact(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }
diff --git a/src/test/auxiliary/logging_right_crate.rs b/src/test/auxiliary/logging_right_crate.rs
index 4fc7de9f7d2..10725981a06 100644
--- a/src/test/auxiliary/logging_right_crate.rs
+++ b/src/test/auxiliary/logging_right_crate.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[feature(phase)];
+#[phase(syntax, link)] extern crate log;
+
 pub fn foo<T>() {
     fn death() -> int { fail!() }
     debug!("{:?}", (||{ death() })());
diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
index aec0bfb1e65..db86be1dfd4 100644
--- a/src/test/bench/core-uint-to-str.rs
+++ b/src/test/bench/core-uint-to-str.rs
@@ -25,6 +25,6 @@ fn main() {
 
     for i in range(0u, n) {
         let x = i.to_str();
-        info!("{}", x);
+        println!("{}", x);
     }
 }
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index bc729acbdf5..be081afc39e 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -40,7 +40,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
         match requests.recv_opt() {
           Some(get_count) => { responses.send(count.clone()); }
           Some(bytes(b)) => {
-            //error!("server: received {:?} bytes", b);
+            //println!("server: received {:?} bytes", b);
             count += b;
           }
           None => { done = true; }
@@ -48,7 +48,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
         }
     }
     responses.send(count);
-    //error!("server exiting");
+    //println!("server exiting");
 }
 
 fn run(args: &[~str]) {
@@ -66,10 +66,10 @@ fn run(args: &[~str]) {
         worker_results.push(builder.future_result());
         builder.spawn(proc() {
             for _ in range(0u, size / workers) {
-                //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
+                //println!("worker {:?}: sending {:?} bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));
             }
-            //error!("worker {:?} exiting", i);
+            //println!("worker {:?} exiting", i);
         });
     }
     task::spawn(proc() {
@@ -80,7 +80,7 @@ fn run(args: &[~str]) {
         r.recv();
     }
 
-    //error!("sending stop message");
+    //println!("sending stop message");
     to_child.send(stop);
     move_out(to_child);
     let result = from_child.recv();
@@ -103,6 +103,6 @@ fn main() {
         args.clone()
     };
 
-    info!("{:?}", args);
+    println!("{:?}", args);
     run(args);
 }
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index a24e830a987..518b2d4c9ef 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -35,7 +35,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
         match requests.recv_opt() {
           Some(get_count) => { responses.send(count.clone()); }
           Some(bytes(b)) => {
-            //error!("server: received {:?} bytes", b);
+            //println!("server: received {:?} bytes", b);
             count += b;
           }
           None => { done = true; }
@@ -43,7 +43,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
         }
     }
     responses.send(count);
-    //error!("server exiting");
+    //println!("server exiting");
 }
 
 fn run(args: &[~str]) {
@@ -60,10 +60,10 @@ fn run(args: &[~str]) {
         worker_results.push(builder.future_result());
         builder.spawn(proc() {
             for _ in range(0u, size / workers) {
-                //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
+                //println!("worker {:?}: sending {:?} bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));
             }
-            //error!("worker {:?} exiting", i);
+            //println!("worker {:?} exiting", i);
         });
         from_parent
     } else {
@@ -74,10 +74,10 @@ fn run(args: &[~str]) {
             worker_results.push(builder.future_result());
             builder.spawn(proc() {
                 for _ in range(0u, size / workers) {
-                    //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
+                    //println!("worker {:?}: sending {:?} bytes", i, num_bytes);
                     to_child.send(bytes(num_bytes));
                 }
-                //error!("worker {:?} exiting", i);
+                //println!("worker {:?} exiting", i);
             });
         }
         from_parent
@@ -90,7 +90,7 @@ fn run(args: &[~str]) {
         r.recv();
     }
 
-    //error!("sending stop message");
+    //println!("sending stop message");
     //to_child.send(stop);
     //move_out(to_child);
     let result = from_child.recv();
@@ -113,6 +113,6 @@ fn main() {
         args.clone()
     };
 
-    info!("{:?}", args);
+    println!("{:?}", args);
     run(args);
 }
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index 6b91d1d534b..6bf25f2149c 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -57,7 +57,7 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
     let mut num_port = Some(num_port);
     // Send/Receive lots of messages.
     for j in range(0u, count) {
-        //error!("task %?, iter %?", i, j);
+        //println!("task %?, iter %?", i, j);
         let num_chan2 = num_chan.take_unwrap();
         let num_port2 = num_port.take_unwrap();
         send(&num_chan2, i * j);
@@ -89,7 +89,7 @@ fn main() {
     let mut futures = ~[];
 
     for i in range(1u, num_tasks) {
-        //error!("spawning %?", i);
+        //println!("spawning %?", i);
         let (new_chan, num_port) = init();
         let num_chan_2 = num_chan.clone();
         let new_future = Future::spawn(proc() {
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index 2d52f125747..90d7da65e1f 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -52,7 +52,7 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
     let mut num_port = Some(num_port);
     // Send/Receive lots of messages.
     for j in range(0u, count) {
-        //error!("task %?, iter %?", i, j);
+        //println!("task %?, iter %?", i, j);
         let num_chan2 = num_chan.take_unwrap();
         let num_port2 = num_port.take_unwrap();
         send(&num_chan2, i * j);
@@ -84,7 +84,7 @@ fn main() {
     let mut futures = ~[];
 
     for i in range(1u, num_tasks) {
-        //error!("spawning %?", i);
+        //println!("spawning %?", i);
         let (new_chan, num_port) = init();
         let num_chan_2 = num_chan.clone();
         let new_future = Future::spawn(proc() {
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 318bd16a8b2..78cd5f4c30a 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -70,7 +70,7 @@ fn stress_task(id: int) {
         let n = 15;
         assert_eq!(fib(n), fib(n));
         i += 1;
-        error!("{}: Completed {} iterations", id, i);
+        println!("{}: Completed {} iterations", id, i);
     }
 }
 
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 839ffe99e16..7f2cd368219 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -41,7 +41,7 @@ fn roundtrip(id: int, n_tasks: int, p: &Receiver<int>, ch: &Sender<int>) {
             return;
           }
           token => {
-            info!("thread: {}   got token: {}", id, token);
+            println!("thread: {}   got token: {}", id, token);
             ch.send(token - 1);
             if token <= n_tasks {
                 return;
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index d4f9d0572b0..e0938a8ae03 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -34,11 +34,11 @@ fn main() {
 
 fn run(repeat: int, depth: int) {
     for _ in range(0, repeat) {
-        info!("starting {:.4f}", precise_time_s());
+        println!("starting {:.4f}", precise_time_s());
         task::try(proc() {
             recurse_or_fail(depth, None)
         });
-        info!("stopping {:.4f}", precise_time_s());
+        println!("stopping {:.4f}", precise_time_s());
     }
 }
 
@@ -71,7 +71,7 @@ fn r(l: @nillist) -> r {
 
 fn recurse_or_fail(depth: int, st: Option<State>) {
     if depth == 0 {
-        info!("unwinding {:.4f}", precise_time_s());
+        println!("unwinding {:.4f}", precise_time_s());
         fail!();
     } else {
         let depth = depth - 1;
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index ff70dac2dde..c3c255b2dc8 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -66,5 +66,5 @@ fn main() {
     let (sum_port, sum_chan) = stream::<int>();
     start_chan.send(sum_chan);
     let sum = sum_port.recv();
-    error!("How many tasks? {} tasks.", sum);
+    println!("How many tasks? {} tasks.", sum);
 }
diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs
index 963a674b5b1..da4b0677f8f 100644
--- a/src/test/compile-fail/asm-in-bad-modifier.rs
+++ b/src/test/compile-fail/asm-in-bad-modifier.rs
@@ -11,7 +11,7 @@
 // ignore-fast #[feature] doesn't work with check-fast
 #[feature(asm)];
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "x86_64")]
diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs
index 5b6f6ce73a8..f183975ffe0 100644
--- a/src/test/compile-fail/asm-out-assign-imm.rs
+++ b/src/test/compile-fail/asm-out-assign-imm.rs
@@ -11,7 +11,7 @@
 // ignore-fast #[feature] doesn't work with check-fast
 #[feature(asm)];
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "x86_64")]
diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs
index 56f0710dc3b..475052b637e 100644
--- a/src/test/compile-fail/asm-out-no-modifier.rs
+++ b/src/test/compile-fail/asm-out-no-modifier.rs
@@ -11,7 +11,7 @@
 // ignore-fast #[feature] doesn't work with check-fast
 #[feature(asm)];
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "x86_64")]
diff --git a/src/test/compile-fail/asm-out-read-uninit.rs b/src/test/compile-fail/asm-out-read-uninit.rs
index 65750eb926b..664db071f82 100644
--- a/src/test/compile-fail/asm-out-read-uninit.rs
+++ b/src/test/compile-fail/asm-out-read-uninit.rs
@@ -11,7 +11,7 @@
 // ignore-fast #[feature] doesn't work with check-fast
 #[feature(asm)];
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "x86_64")]
diff --git a/src/test/compile-fail/assign-imm-local-twice.rs b/src/test/compile-fail/assign-imm-local-twice.rs
index e11b47a1b58..77f47a028d6 100644
--- a/src/test/compile-fail/assign-imm-local-twice.rs
+++ b/src/test/compile-fail/assign-imm-local-twice.rs
@@ -11,9 +11,9 @@
 fn test() {
     let v: int;
     v = 1; //~ NOTE prior assignment occurs here
-    info!("v={}", v);
+    println!("v={}", v);
     v = 2; //~ ERROR re-assignment of immutable variable
-    info!("v={}", v);
+    println!("v={}", v);
 }
 
 fn main() {
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index f300bd51b24..4a392960a65 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -27,5 +27,5 @@ fn cat(in_x : uint, in_y : int) -> cat {
 
 fn main() {
   let nyan : cat = cat(52u, 99);
-  nyan.speak = || info!("meow"); //~ ERROR attempted to take value of method
+  nyan.speak = || println!("meow"); //~ ERROR attempted to take value of method
 }
diff --git a/src/test/compile-fail/attr-before-ext.rs b/src/test/compile-fail/attr-before-ext.rs
index 3102a1a9d99..098c5aaec54 100644
--- a/src/test/compile-fail/attr-before-ext.rs
+++ b/src/test/compile-fail/attr-before-ext.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     #[attr] //~ ERROR expected item after attributes
-    info!("hi");
+    println!("hi");
 }
diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs
index 1741210f9ed..8ccf2a9e675 100644
--- a/src/test/compile-fail/autoderef-full-lval.rs
+++ b/src/test/compile-fail/autoderef-full-lval.rs
@@ -23,12 +23,12 @@ fn main() {
     let a: clam = clam{x: @1, y: @2};
     let b: clam = clam{x: @10, y: @20};
     let z: int = a.x + b.y; //~ ERROR binary operation `+` cannot be applied to type `@int`
-    info!("{:?}", z);
+    println!("{:?}", z);
     assert_eq!(z, 21);
     let forty: fish = fish{a: @40};
     let two: fish = fish{a: @2};
     let answer: int = forty.a + two.a;
     //~^ ERROR binary operation `+` cannot be applied to type `@int`
-    info!("{:?}", answer);
+    println!("{:?}", answer);
     assert_eq!(answer, 42);
 }
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 08ced2b002d..92643eca3c8 100644
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -11,4 +11,4 @@
 // error-pattern:expected `~str` but found `int`
 
 static i: ~str = 10i;
-fn main() { info!("{:?}", i); }
+fn main() { println!("{:?}", i); }
diff --git a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-1.rs b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-1.rs
index 3d1cca46085..a60348c4a3a 100644
--- a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-1.rs
+++ b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-1.rs
@@ -12,7 +12,7 @@ struct X { x: () }
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("destructor runs");
+        println!("destructor runs");
     }
 }
 
diff --git a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-2.rs b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-2.rs
index a1803a621a5..87904399e03 100644
--- a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-2.rs
+++ b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-2.rs
@@ -12,7 +12,7 @@ struct X { x: (), }
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("destructor runs");
+        println!("destructor runs");
     }
 }
 
diff --git a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-3.rs b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-3.rs
index 34a9c0b8fc2..ba011d28925 100644
--- a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-3.rs
+++ b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-3.rs
@@ -12,7 +12,7 @@ struct X { x: (), }
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("destructor runs");
+        println!("destructor runs");
     }
 }
 
diff --git a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-4.rs b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-4.rs
index 2aa3379993b..6858b7200db 100644
--- a/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-4.rs
+++ b/src/test/compile-fail/bind-by-move-neither-can-live-while-the-other-survives-4.rs
@@ -12,7 +12,7 @@ struct X { x: (), }
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("destructor runs");
+        println!("destructor runs");
     }
 }
 
diff --git a/src/test/compile-fail/bind-by-move-no-sub-bindings.rs b/src/test/compile-fail/bind-by-move-no-sub-bindings.rs
index 7143ce0252b..34b83af1d2e 100644
--- a/src/test/compile-fail/bind-by-move-no-sub-bindings.rs
+++ b/src/test/compile-fail/bind-by-move-no-sub-bindings.rs
@@ -12,7 +12,7 @@ struct X { x: (), }
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("destructor runs");
+        println!("destructor runs");
     }
 }
 
diff --git a/src/test/compile-fail/block-coerce-no.rs b/src/test/compile-fail/block-coerce-no.rs
index d07c3feb194..98d81db8261 100644
--- a/src/test/compile-fail/block-coerce-no.rs
+++ b/src/test/compile-fail/block-coerce-no.rs
@@ -21,6 +21,6 @@ fn coerce(b: ||) -> extern fn() {
 
 fn main() {
     let i = 8;
-    let f = coerce(|| error!("{:?}", i) );
+    let f = coerce(|| println!("{:?}", i) );
     f();
 }
diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs
index 1bd40ce24bc..cc0ed214103 100644
--- a/src/test/compile-fail/bogus-tag.rs
+++ b/src/test/compile-fail/bogus-tag.rs
@@ -16,7 +16,7 @@ enum color { rgb(int, int, int), rgba(int, int, int, int), }
 fn main() {
     let red: color = rgb(255, 0, 0);
     match red {
-      rgb(r, g, b) => { info!("rgb"); }
-      hsl(h, s, l) => { info!("hsl"); }
+      rgb(r, g, b) => { println!("rgb"); }
+      hsl(h, s, l) => { println!("hsl"); }
     }
 }
diff --git a/src/test/compile-fail/borrowck-and-init.rs b/src/test/compile-fail/borrowck-and-init.rs
index 134390d0b59..0f07cab3acc 100644
--- a/src/test/compile-fail/borrowck-and-init.rs
+++ b/src/test/compile-fail/borrowck-and-init.rs
@@ -11,6 +11,6 @@
 fn main() {
     let i: int;
 
-    info!("{}", false && { i = 5; true });
-    info!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
+    println!("{}", false && { i = 5; true });
+    println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
 }
diff --git a/src/test/compile-fail/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck-assign-comp-idx.rs
index dec248a3015..64afb4861c3 100644
--- a/src/test/compile-fail/borrowck-assign-comp-idx.rs
+++ b/src/test/compile-fail/borrowck-assign-comp-idx.rs
@@ -21,7 +21,7 @@ fn a() {
 
     p[0] = 5; //~ ERROR cannot assign
 
-    info!("{}", *q);
+    println!("{}", *q);
 }
 
 fn borrow(_x: &[int], _f: ||) {}
diff --git a/src/test/compile-fail/borrowck-block-unint.rs b/src/test/compile-fail/borrowck-block-unint.rs
index fc865e271e3..a37717ed5d9 100644
--- a/src/test/compile-fail/borrowck-block-unint.rs
+++ b/src/test/compile-fail/borrowck-block-unint.rs
@@ -12,6 +12,6 @@ fn force(f: ||) { f(); }
 fn main() {
     let x: int;
     force(|| {  //~ ERROR capture of possibly uninitialized variable: `x`
-        info!("{}", x);
+        println!("{}", x);
     });
 }
diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
index 646ec692863..4fccb5c3bca 100644
--- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
+++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
@@ -16,7 +16,7 @@ struct defer<'a> {
 impl<'a> Drop for defer<'a> {
     fn drop(&mut self) {
         unsafe {
-            error!("{:?}", self.x);
+            println!("{:?}", self.x);
         }
     }
 }
diff --git a/src/test/compile-fail/borrowck-break-uninit-2.rs b/src/test/compile-fail/borrowck-break-uninit-2.rs
index accb9076974..de18759e30a 100644
--- a/src/test/compile-fail/borrowck-break-uninit-2.rs
+++ b/src/test/compile-fail/borrowck-break-uninit-2.rs
@@ -16,9 +16,9 @@ fn foo() -> int {
         x = 0;
     }
 
-    info!("{}", x); //~ ERROR use of possibly uninitialized variable: `x`
+    println!("{}", x); //~ ERROR use of possibly uninitialized variable: `x`
 
     return 17;
 }
 
-fn main() { info!("{}", foo()); }
+fn main() { println!("{}", foo()); }
diff --git a/src/test/compile-fail/borrowck-break-uninit.rs b/src/test/compile-fail/borrowck-break-uninit.rs
index d49e79d2c64..aa7ce4fa347 100644
--- a/src/test/compile-fail/borrowck-break-uninit.rs
+++ b/src/test/compile-fail/borrowck-break-uninit.rs
@@ -16,9 +16,9 @@ fn foo() -> int {
         x = 0;
     }
 
-    info!("{}", x); //~ ERROR use of possibly uninitialized variable: `x`
+    println!("{}", x); //~ ERROR use of possibly uninitialized variable: `x`
 
     return 17;
 }
 
-fn main() { info!("{}", foo()); }
+fn main() { println!("{}", foo()); }
diff --git a/src/test/compile-fail/borrowck-if-no-else.rs b/src/test/compile-fail/borrowck-if-no-else.rs
index 8dc590b47f0..a35b36fd78c 100644
--- a/src/test/compile-fail/borrowck-if-no-else.rs
+++ b/src/test/compile-fail/borrowck-if-no-else.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 fn main() {
     let x: int; if 1 > 2 { x = 10; }
diff --git a/src/test/compile-fail/borrowck-if-with-else.rs b/src/test/compile-fail/borrowck-if-with-else.rs
index 55fb8222634..dabe0a59429 100644
--- a/src/test/compile-fail/borrowck-if-with-else.rs
+++ b/src/test/compile-fail/borrowck-if-with-else.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { info!("{:?}", x); }
+fn foo(x: int) { println!("{:?}", x); }
 
 fn main() {
     let x: int;
     if 1 > 2 {
-        info!("whoops");
+        println!("whoops");
     } else {
         x = 10;
     }
diff --git a/src/test/compile-fail/borrowck-init-in-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
index f6bb2f54283..c44e2bee052 100644
--- a/src/test/compile-fail/borrowck-init-in-fn-expr.rs
+++ b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
@@ -13,5 +13,5 @@ fn main() {
         let i: int;
         i //~ ERROR use of possibly uninitialized variable: `i`
     };
-    error!("{:?}", f());
+    println!("{:?}", f());
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
index 18fd4111018..0fa2ee5be17 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -18,7 +18,7 @@ fn box_imm() {
     let v = ~3;
     let _w = &v;
     task::spawn(proc() {
-        info!("v={}", *v);
+        println!("v={}", *v);
         //~^ ERROR cannot move `v` into closure
     });
 }
@@ -27,7 +27,7 @@ fn box_imm_explicit() {
     let v = ~3;
     let _w = &v;
     task::spawn(proc() {
-        info!("v={}", *v);
+        println!("v={}", *v);
         //~^ ERROR cannot move
     });
 }
diff --git a/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs b/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs
index 67b83ee84e4..e1e0bb4ceca 100644
--- a/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs
+++ b/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs
@@ -34,7 +34,7 @@ pub fn main() {
                 }
             }
             let z = tail[0].clone();
-            info!("{:?}", z);
+            println!("{:?}", z);
         }
         _ => {
             unreachable!();
diff --git a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
index cab2a5565f4..738652dddb3 100644
--- a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
+++ b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
@@ -12,5 +12,5 @@ fn main() {
     let x: int = 3;
     let y: &mut int = &mut x; //~ ERROR cannot borrow
     *y = 5;
-    info!("{:?}", *y);
+    println!("{:?}", *y);
 }
diff --git a/src/test/compile-fail/borrowck-or-init.rs b/src/test/compile-fail/borrowck-or-init.rs
index f878afce969..270eeca4c4b 100644
--- a/src/test/compile-fail/borrowck-or-init.rs
+++ b/src/test/compile-fail/borrowck-or-init.rs
@@ -11,6 +11,6 @@
 fn main() {
     let i: int;
 
-    info!("{}", false || { i = 5; true });
-    info!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
+    println!("{}", false || { i = 5; true });
+    println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
 }
diff --git a/src/test/compile-fail/borrowck-uninit.rs b/src/test/compile-fail/borrowck-uninit.rs
index a6ce736c89b..a64216df6c7 100644
--- a/src/test/compile-fail/borrowck-uninit.rs
+++ b/src/test/compile-fail/borrowck-uninit.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 fn main() {
     let x: int;
diff --git a/src/test/compile-fail/borrowck-while-break.rs b/src/test/compile-fail/borrowck-while-break.rs
index e5d4b6ef48c..8cdf1da5c93 100644
--- a/src/test/compile-fail/borrowck-while-break.rs
+++ b/src/test/compile-fail/borrowck-while-break.rs
@@ -14,7 +14,7 @@ fn test(cond: bool) {
         v = 3;
         break;
     }
-    info!("{}", v); //~ ERROR use of possibly uninitialized variable: `v`
+    println!("{}", v); //~ ERROR use of possibly uninitialized variable: `v`
 }
 
 fn main() {
diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs
index 18f6fc25149..5d8932c6e6f 100644
--- a/src/test/compile-fail/class-cast-to-trait.rs
+++ b/src/test/compile-fail/class-cast-to-trait.rs
@@ -22,12 +22,12 @@ struct cat {
 impl cat {
   pub fn eat(&self) -> bool {
     if self.how_hungry > 0 {
-        error!("OM NOM NOM");
+        println!("OM NOM NOM");
         self.how_hungry -= 2;
         return true;
     }
     else {
-        error!("Not hungry!");
+        println!("Not hungry!");
         return false;
     }
   }
@@ -40,7 +40,7 @@ impl noisy for cat {
 
 impl cat {
     fn meow(&self) {
-      error!("Meow");
+      println!("Meow");
       self.meows += 1;
       if self.meows % 5 == 0 {
           self.how_hungry += 1;
diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs
index c27c27b5942..b9e7004bd7c 100644
--- a/src/test/compile-fail/class-missing-self.rs
+++ b/src/test/compile-fail/class-missing-self.rs
@@ -15,7 +15,7 @@ struct cat {
 impl cat {
     fn sleep(&self) { loop{} }
     fn meow(&self) {
-      error!("Meow");
+      println!("Meow");
       meows += 1u; //~ ERROR unresolved name
       sleep();     //~ ERROR unresolved name
     }
diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs
index 7e928e190a3..ac893277749 100644
--- a/src/test/compile-fail/copy-a-resource.rs
+++ b/src/test/compile-fail/copy-a-resource.rs
@@ -26,5 +26,5 @@ fn main() {
     let x = foo(10);
     let _y = x.clone();
     //~^ ERROR does not implement any method in scope
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/compile-fail/dead-code-ret.rs b/src/test/compile-fail/dead-code-ret.rs
index 70e76b9fde1..c09938b2f7d 100644
--- a/src/test/compile-fail/dead-code-ret.rs
+++ b/src/test/compile-fail/dead-code-ret.rs
@@ -14,5 +14,5 @@
 
 fn main() {
     return;
-    info!("Paul is dead");
+    println!("Paul is dead");
 }
diff --git a/src/test/compile-fail/disallowed-deconstructing-destructing-struct-let.rs b/src/test/compile-fail/disallowed-deconstructing-destructing-struct-let.rs
index 945c3d62952..af543b8d782 100644
--- a/src/test/compile-fail/disallowed-deconstructing-destructing-struct-let.rs
+++ b/src/test/compile-fail/disallowed-deconstructing-destructing-struct-let.rs
@@ -14,7 +14,7 @@ struct X {
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("value: {}", self.x);
+        println!("value: {}", self.x);
     }
 }
 
@@ -26,5 +26,5 @@ fn unwrap(x: X) -> ~str {
 fn main() {
     let x = X { x: ~"hello" };
     let y = unwrap(x);
-    error!("contents: {}", y);
+    println!("contents: {}", y);
 }
diff --git a/src/test/compile-fail/disallowed-deconstructing-destructing-struct-match.rs b/src/test/compile-fail/disallowed-deconstructing-destructing-struct-match.rs
index 0432920c1a6..b716a7dd023 100644
--- a/src/test/compile-fail/disallowed-deconstructing-destructing-struct-match.rs
+++ b/src/test/compile-fail/disallowed-deconstructing-destructing-struct-match.rs
@@ -14,7 +14,7 @@ struct X {
 
 impl Drop for X {
     fn drop(&mut self) {
-        error!("value: {}", self.x);
+        println!("value: {}", self.x);
     }
 }
 
@@ -22,7 +22,7 @@ fn main() {
     let x = X { x: ~"hello" };
 
     match x {
-        X { x: y } => error!("contents: {}", y)
+        X { x: y } => println!("contents: {}", y)
         //~^ ERROR cannot move out of type `X`, which defines the `Drop` trait
     }
 }
diff --git a/src/test/compile-fail/does-nothing.rs b/src/test/compile-fail/does-nothing.rs
index 23b9f048242..9b82ead0428 100644
--- a/src/test/compile-fail/does-nothing.rs
+++ b/src/test/compile-fail/does-nothing.rs
@@ -9,4 +9,4 @@
 // except according to those terms.
 
 // error-pattern: unresolved name `this_does_nothing_what_the`.
-fn main() { info!("doing"); this_does_nothing_what_the; info!("boing"); }
+fn main() { println!("doing"); this_does_nothing_what_the; println!("boing"); }
diff --git a/src/test/compile-fail/export2.rs b/src/test/compile-fail/export2.rs
index 22762eb4a7e..6104c02c90a 100644
--- a/src/test/compile-fail/export2.rs
+++ b/src/test/compile-fail/export2.rs
@@ -15,7 +15,7 @@ mod foo {
 }
 
 mod bar {
-    fn x() { info!("x"); }
+    fn x() { println!("x"); }
 
     pub fn y() { }
 }
diff --git a/src/test/compile-fail/if-without-else-result.rs b/src/test/compile-fail/if-without-else-result.rs
index dcda6afa6ca..38cae632320 100644
--- a/src/test/compile-fail/if-without-else-result.rs
+++ b/src/test/compile-fail/if-without-else-result.rs
@@ -12,5 +12,5 @@
 
 fn main() {
     let a = if true { true };
-    info!("{:?}", a);
+    println!("{:?}", a);
 }
diff --git a/src/test/compile-fail/import-glob-0.rs b/src/test/compile-fail/import-glob-0.rs
index 124d4631601..973e36e494c 100644
--- a/src/test/compile-fail/import-glob-0.rs
+++ b/src/test/compile-fail/import-glob-0.rs
@@ -15,10 +15,10 @@
 use module_of_many_things::*;
 
 mod module_of_many_things {
-    pub fn f1() { info!("f1"); }
-    pub fn f2() { info!("f2"); }
-    fn f3() { info!("f3"); }
-    pub fn f4() { info!("f4"); }
+    pub fn f1() { println!("f1"); }
+    pub fn f2() { println!("f2"); }
+    fn f3() { println!("f3"); }
+    pub fn f4() { println!("f4"); }
 }
 
 
diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs
index ae5a0f04e2c..3f5127a55b8 100644
--- a/src/test/compile-fail/import-glob-circular.rs
+++ b/src/test/compile-fail/import-glob-circular.rs
@@ -14,13 +14,13 @@
 
 mod circ1 {
     pub use circ2::f2;
-    pub fn f1() { info!("f1"); }
+    pub fn f1() { println!("f1"); }
     pub fn common() -> uint { return 0u; }
 }
 
 mod circ2 {
     pub use circ1::f1;
-    pub fn f2() { info!("f2"); }
+    pub fn f2() { println!("f2"); }
     pub fn common() -> uint { return 1u; }
 }
 
diff --git a/src/test/compile-fail/import.rs b/src/test/compile-fail/import.rs
index 5177dc4e475..7f3319e6d90 100644
--- a/src/test/compile-fail/import.rs
+++ b/src/test/compile-fail/import.rs
@@ -12,6 +12,6 @@
 use zed::bar;
 use zed::baz;
 mod zed {
-    pub fn bar() { info!("bar"); }
+    pub fn bar() { println!("bar"); }
 }
 fn main(args: ~[str]) { bar(); }
diff --git a/src/test/compile-fail/import2.rs b/src/test/compile-fail/import2.rs
index e67a79130b1..721176e2e88 100644
--- a/src/test/compile-fail/import2.rs
+++ b/src/test/compile-fail/import2.rs
@@ -13,6 +13,6 @@ use baz::zed::bar;  //~ ERROR unresolved import
 
 mod baz {}
 mod zed {
-    pub fn bar() { info!("bar3"); }
+    pub fn bar() { println!("bar3"); }
 }
 fn main(args: ~[str]) { bar(); }
diff --git a/src/test/compile-fail/import3.rs b/src/test/compile-fail/import3.rs
index 7a7f4f20aea..bd07433eeb0 100644
--- a/src/test/compile-fail/import3.rs
+++ b/src/test/compile-fail/import3.rs
@@ -11,4 +11,4 @@
 // error-pattern: unresolved
 use main::bar;
 
-fn main(args: ~[str]) { info!("foo"); }
+fn main(args: ~[str]) { println!("foo"); }
diff --git a/src/test/compile-fail/import4.rs b/src/test/compile-fail/import4.rs
index 087842d78c7..af4d0ebe6ba 100644
--- a/src/test/compile-fail/import4.rs
+++ b/src/test/compile-fail/import4.rs
@@ -13,4 +13,4 @@
 mod a { pub use b::foo; }
 mod b { pub use a::foo; }
 
-fn main(args: ~[str]) { info!("loop"); }
+fn main(args: ~[str]) { println!("loop"); }
diff --git a/src/test/compile-fail/issue-1448-2.rs b/src/test/compile-fail/issue-1448-2.rs
index e2ca7641500..3daced7a5ac 100644
--- a/src/test/compile-fail/issue-1448-2.rs
+++ b/src/test/compile-fail/issue-1448-2.rs
@@ -13,5 +13,5 @@
 fn foo(a: uint) -> uint { a }
 
 fn main() {
-    info!("{:u}", foo(10i)); //~ ERROR mismatched types
+    println!("{:u}", foo(10i)); //~ ERROR mismatched types
 }
diff --git a/src/test/compile-fail/issue-1476.rs b/src/test/compile-fail/issue-1476.rs
index ed2e75c4fa6..80e0d037f7c 100644
--- a/src/test/compile-fail/issue-1476.rs
+++ b/src/test/compile-fail/issue-1476.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    error!("{:?}", x); //~ ERROR unresolved name `x`.
+    println!("{:?}", x); //~ ERROR unresolved name `x`.
 }
diff --git a/src/test/compile-fail/issue-2281-part1.rs b/src/test/compile-fail/issue-2281-part1.rs
index 7896d91443d..bb24192445e 100644
--- a/src/test/compile-fail/issue-2281-part1.rs
+++ b/src/test/compile-fail/issue-2281-part1.rs
@@ -10,4 +10,4 @@
 
 // error-pattern: unresolved name `foobar`.
 
-fn main(args: ~[str]) { info!("{:?}", foobar); }
+fn main(args: ~[str]) { println!("{:?}", foobar); }
diff --git a/src/test/compile-fail/issue-2823.rs b/src/test/compile-fail/issue-2823.rs
index 790a5fac183..4106a775248 100644
--- a/src/test/compile-fail/issue-2823.rs
+++ b/src/test/compile-fail/issue-2823.rs
@@ -14,7 +14,7 @@ struct C {
 
 impl Drop for C {
     fn drop(&mut self) {
-        error!("dropping: {:?}", self.x);
+        println!("dropping: {:?}", self.x);
     }
 }
 
diff --git a/src/test/compile-fail/issue-3038.rs b/src/test/compile-fail/issue-3038.rs
index 691bd3b4211..684318bafc6 100644
--- a/src/test/compile-fail/issue-3038.rs
+++ b/src/test/compile-fail/issue-3038.rs
@@ -19,13 +19,13 @@ fn main()
 {
 
     let _z = match g(1, 2) {
-      g(x, x) => { info!("{:?}", x + x); }
+      g(x, x) => { println!("{:?}", x + x); }
       //~^ ERROR identifier `x` is bound more than once in the same pattern
     };
 
     let _z = match i(l(1, 2), m(3, 4)) {
       i(l(x, _), m(_, x))  //~ ERROR identifier `x` is bound more than once in the same pattern
-        => { error!("{:?}", x + x); }
+        => { println!("{:?}", x + x); }
     };
 
     let _z = match (1, 2) {
diff --git a/src/test/compile-fail/issue-3099.rs b/src/test/compile-fail/issue-3099.rs
index bb220091a13..85989c4a40a 100644
--- a/src/test/compile-fail/issue-3099.rs
+++ b/src/test/compile-fail/issue-3099.rs
@@ -17,5 +17,5 @@ fn a(x: ~str, y: ~str) -> ~str { //~ ERROR duplicate definition of value `a`
 }
 
 fn main() {
-    info!("Result: ");
+    println!("Result: ");
 }
diff --git a/src/test/compile-fail/issue-3521-2.rs b/src/test/compile-fail/issue-3521-2.rs
index db07d9a94e8..cdfc9906776 100644
--- a/src/test/compile-fail/issue-3521-2.rs
+++ b/src/test/compile-fail/issue-3521-2.rs
@@ -13,5 +13,5 @@ fn main() {
 
     static y: int = foo + 1; //~ ERROR: attempt to use a non-constant value in a constant
 
-    error!("{}", y);
+    println!("{}", y);
 }
diff --git a/src/test/compile-fail/issue-3521.rs b/src/test/compile-fail/issue-3521.rs
index 94ca74d2b6a..f9fb2daaf58 100644
--- a/src/test/compile-fail/issue-3521.rs
+++ b/src/test/compile-fail/issue-3521.rs
@@ -15,5 +15,5 @@ fn main() {
         Bar = foo //~ ERROR attempt to use a non-constant value in a constant
     }
 
-    error!("{:?}", Bar);
+    println!("{:?}", Bar);
 }
diff --git a/src/test/compile-fail/liveness-bad-bang-2.rs b/src/test/compile-fail/liveness-bad-bang-2.rs
index eeb07c71e9b..24a02821ee2 100644
--- a/src/test/compile-fail/liveness-bad-bang-2.rs
+++ b/src/test/compile-fail/liveness-bad-bang-2.rs
@@ -11,6 +11,6 @@
 // Tests that a function with a ! annotation always actually fails
 // error-pattern: some control paths may return
 
-fn bad_bang(i: uint) -> ! { info!("{}", 3); }
+fn bad_bang(i: uint) -> ! { println!("{}", 3); }
 
 fn main() { bad_bang(5u); }
diff --git a/src/test/compile-fail/liveness-closure-require-ret.rs b/src/test/compile-fail/liveness-closure-require-ret.rs
index 9d46202d64e..676d5212e99 100644
--- a/src/test/compile-fail/liveness-closure-require-ret.rs
+++ b/src/test/compile-fail/liveness-closure-require-ret.rs
@@ -9,4 +9,4 @@
 // except according to those terms.
 
 fn force(f: || -> int) -> int { f() }
-fn main() { info!("{:?}", force(|| {})); } //~ ERROR mismatched types
+fn main() { println!("{:?}", force(|| {})); } //~ ERROR mismatched types
diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs
index 6ba7d57ef88..a64d7578af3 100644
--- a/src/test/compile-fail/liveness-move-in-loop.rs
+++ b/src/test/compile-fail/liveness-move-in-loop.rs
@@ -12,7 +12,7 @@ fn main() {
     let y: ~int = ~42;
     let mut x: ~int;
     loop {
-        info!("{:?}", y);
+        println!("{:?}", y);
         loop {
             loop {
                 loop {
diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs
index ad0cdc5451f..8aa85c03ad4 100644
--- a/src/test/compile-fail/liveness-move-in-while.rs
+++ b/src/test/compile-fail/liveness-move-in-while.rs
@@ -13,7 +13,7 @@ fn main() {
     let y: ~int = ~42;
     let mut x: ~int;
     loop {
-        info!("{:?}", y); //~ ERROR use of moved value: `y`
+        println!("{:?}", y); //~ ERROR use of moved value: `y`
         while true { while true { while true { x = y; x.clone(); } } }
         //~^ ERROR use of moved value: `y`
     }
diff --git a/src/test/compile-fail/liveness-use-after-move.rs b/src/test/compile-fail/liveness-use-after-move.rs
index 83b8d79756f..eccb3784325 100644
--- a/src/test/compile-fail/liveness-use-after-move.rs
+++ b/src/test/compile-fail/liveness-use-after-move.rs
@@ -11,6 +11,6 @@
 fn main() {
     let x = ~5;
     let y = x;
-    info!("{:?}", *x); //~ ERROR use of moved value: `x`
+    println!("{:?}", *x); //~ ERROR use of moved value: `x`
     y.clone();
 }
diff --git a/src/test/compile-fail/liveness-use-after-send.rs b/src/test/compile-fail/liveness-use-after-send.rs
index 7bc277c2eac..8747d055ff9 100644
--- a/src/test/compile-fail/liveness-use-after-send.rs
+++ b/src/test/compile-fail/liveness-use-after-send.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn send<T:Send>(ch: _chan<T>, data: T) {
-    info!("{:?}", ch);
-    info!("{:?}", data);
+    println!("{:?}", ch);
+    println!("{:?}", data);
     fail!();
 }
 
@@ -20,7 +20,7 @@ struct _chan<T>(int);
 // message after the send deinitializes it
 fn test00_start(ch: _chan<~int>, message: ~int, _count: ~int) {
     send(ch, message);
-    info!("{:?}", message); //~ ERROR use of moved value: `message`
+    println!("{:?}", message); //~ ERROR use of moved value: `message`
 }
 
 fn main() { fail!(); }
diff --git a/src/test/compile-fail/match-join.rs b/src/test/compile-fail/match-join.rs
index 8155a2fbda3..3e1c9e850fa 100644
--- a/src/test/compile-fail/match-join.rs
+++ b/src/test/compile-fail/match-join.rs
@@ -16,6 +16,6 @@ fn my_fail() -> ! { fail!(); }
 fn main() {
     match true { false => { my_fail(); } true => { } }
 
-    info!("{:?}", x); //~ ERROR unresolved name `x`.
+    println!("{:?}", x); //~ ERROR unresolved name `x`.
     let x: int;
 }
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 8df156d8332..02e1f82e709 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -26,5 +26,5 @@ fn main() {
 
     assert_eq!((arc_v.get())[2], 3);
 
-    info!("{:?}", arc_v);
+    println!("{:?}", arc_v);
 }
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index b387d3a1719..5fed317fb09 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -24,5 +24,5 @@ fn main() {
 
     assert_eq!((arc_v.get())[2], 3); //~ ERROR use of moved value: `arc_v`
 
-    info!("{:?}", arc_v); //~ ERROR use of moved value: `arc_v`
+    println!("{:?}", arc_v); //~ ERROR use of moved value: `arc_v`
 }
diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs
index 9e564e997e6..68077d61c9f 100644
--- a/src/test/compile-fail/no-send-res-ports.rs
+++ b/src/test/compile-fail/no-send-res-ports.rs
@@ -34,6 +34,6 @@ fn main() {
 
     task::spawn(proc() {
         let y = x;   //~ ERROR does not fulfill `Send`
-        error!("{:?}", y);
+        println!("{:?}", y);
     });
 }
diff --git a/src/test/compile-fail/noncopyable-class.rs b/src/test/compile-fail/noncopyable-class.rs
index e57ac5726fb..778f3a3b997 100644
--- a/src/test/compile-fail/noncopyable-class.rs
+++ b/src/test/compile-fail/noncopyable-class.rs
@@ -39,5 +39,5 @@ fn foo(i:int) -> foo {
 fn main() {
     let x = foo(10);
     let _y = x.clone(); //~ ERROR does not implement any method in scope
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/compile-fail/nonscalar-cast.rs b/src/test/compile-fail/nonscalar-cast.rs
index 5c7a85a0323..c0749984cc9 100644
--- a/src/test/compile-fail/nonscalar-cast.rs
+++ b/src/test/compile-fail/nonscalar-cast.rs
@@ -15,5 +15,5 @@ struct foo {
 }
 
 fn main() {
-    info!("{:?}", foo{ x: 1 } as int);
+    println!("{:?}", foo{ x: 1 } as int);
 }
diff --git a/src/test/compile-fail/oversized-literal.rs b/src/test/compile-fail/oversized-literal.rs
index 1c4316672f3..0b5c6ac4fb3 100644
--- a/src/test/compile-fail/oversized-literal.rs
+++ b/src/test/compile-fail/oversized-literal.rs
@@ -10,4 +10,4 @@
 
 // compile-flags: -D type-overflow
 
-fn main() { info!("{}", 300u8); } //~ error: literal out of range for its type
+fn main() { println!("{}", 300u8); } //~ error: literal out of range for its type
diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs
index 991a4ed9e09..c74d80df5dc 100644
--- a/src/test/compile-fail/packed-struct-generic-transmute.rs
+++ b/src/test/compile-fail/packed-struct-generic-transmute.rs
@@ -32,6 +32,6 @@ fn main() {
     let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
     unsafe {
         let oof: Oof<[u8, .. 5], i32> = cast::transmute(foo);
-        info!("{:?}", oof);
+        println!("{:?}", oof);
     }
 }
diff --git a/src/test/compile-fail/packed-struct-transmute.rs b/src/test/compile-fail/packed-struct-transmute.rs
index 58c5aabba12..b9a8a53469d 100644
--- a/src/test/compile-fail/packed-struct-transmute.rs
+++ b/src/test/compile-fail/packed-struct-transmute.rs
@@ -32,6 +32,6 @@ fn main() {
     let foo = Foo { bar: 1, baz: 10 };
     unsafe {
         let oof: Oof = cast::transmute(foo);
-        info!("{:?}", oof);
+        println!("{:?}", oof);
     }
 }
diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index 94614e4970a..22cc9fd2831 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -15,7 +15,7 @@ enum bar { t1((), Option<~[int]>), t2, }
 fn foo(t: bar) {
     match t {
       t1(_, Some::<int>(x)) => {
-        info!("{:?}", x);
+        println!("{:?}", x);
       }
       _ => { fail!(); }
     }
diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs
index 9c9b4a9f4d5..6479a9404e2 100644
--- a/src/test/compile-fail/pinned-deep-copy.rs
+++ b/src/test/compile-fail/pinned-deep-copy.rs
@@ -41,7 +41,7 @@ fn main() {
         // Can't do this copy
         let x = ~~~A {y: r(i)};
         let _z = x.clone(); //~ ERROR failed to find an implementation
-        info!("{:?}", x);
+        println!("{:?}", x);
     }
-    error!("{:?}", *i);
+    println!("{:?}", *i);
 }
diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs
index ce89b66cd5b..fb2dbacef84 100644
--- a/src/test/compile-fail/regions-addr-of-self.rs
+++ b/src/test/compile-fail/regions-addr-of-self.rs
@@ -33,5 +33,5 @@ fn dog() -> dog {
 fn main() {
     let mut d = dog();
     d.chase_cat();
-    info!("cats_chased: {}", d.cats_chased);
+    println!("cats_chased: {}", d.cats_chased);
 }
diff --git a/src/test/compile-fail/regions-freevar.rs b/src/test/compile-fail/regions-freevar.rs
index af460dbdd78..68920065d19 100644
--- a/src/test/compile-fail/regions-freevar.rs
+++ b/src/test/compile-fail/regions-freevar.rs
@@ -13,6 +13,6 @@ fn wants_static_fn(_x: 'static ||) {}
 fn main() {
     let i = 3;
     wants_static_fn(|| { //~ ERROR cannot infer
-        info!("i={}", i);
+        println!("i={}", i);
     })
 }
diff --git a/src/test/compile-fail/regions-ret-borrowed-1.rs b/src/test/compile-fail/regions-ret-borrowed-1.rs
index 0c335b9d557..068ecb7118f 100644
--- a/src/test/compile-fail/regions-ret-borrowed-1.rs
+++ b/src/test/compile-fail/regions-ret-borrowed-1.rs
@@ -24,5 +24,5 @@ fn return_it<'a>() -> &'a int {
 
 fn main() {
     let x = return_it();
-    info!("foo={}", *x);
+    println!("foo={}", *x);
 }
diff --git a/src/test/compile-fail/regions-ret-borrowed.rs b/src/test/compile-fail/regions-ret-borrowed.rs
index 469421751df..c20764e0728 100644
--- a/src/test/compile-fail/regions-ret-borrowed.rs
+++ b/src/test/compile-fail/regions-ret-borrowed.rs
@@ -27,5 +27,5 @@ fn return_it() -> &int {
 
 fn main() {
     let x = return_it();
-    info!("foo={}", *x);
+    println!("foo={}", *x);
 }
diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs
index bf62247e7e7..da9e24b7314 100644
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -19,5 +19,5 @@ impl Drop for r {
 fn main() {
     let i = ~r { b: true };
     let _j = i.clone(); //~ ERROR failed to find an implementation
-    info!("{:?}", i);
+    println!("{:?}", i);
 }
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index c604e66507e..a77d1b06f17 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -35,6 +35,6 @@ fn main() {
     let r2 = ~[~r { i: i2 }];
     f(r1.clone(), r2.clone());
     //~^ ERROR failed to find an implementation of
-    info!("{:?}", (r2, i1.get()));
-    info!("{:?}", (r1, i2.get()));
+    println!("{:?}", (r2, i1.get()));
+    println!("{:?}", (r1, i2.get()));
 }
diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs
index dc3895d0190..be3f5ba7da8 100644
--- a/src/test/compile-fail/unsupported-cast.rs
+++ b/src/test/compile-fail/unsupported-cast.rs
@@ -13,5 +13,5 @@
 use std::libc;
 
 fn main() {
-  info!("{:?}", 1.0 as *libc::FILE); // Can't cast float to foreign.
+  println!("{:?}", 1.0 as *libc::FILE); // Can't cast float to foreign.
 }
diff --git a/src/test/compile-fail/vec-field.rs b/src/test/compile-fail/vec-field.rs
index d97c32a64a4..19052d923e9 100644
--- a/src/test/compile-fail/vec-field.rs
+++ b/src/test/compile-fail/vec-field.rs
@@ -13,7 +13,7 @@
 
 fn f() {
     let v = ~[1i];
-    info!("{}", v.some_field_name); //type error
+    println!("{}", 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 3545392d5d9..d93fe4f48d0 100644
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -25,5 +25,5 @@ fn main() {
     let i = ~[r(0)];
     let j = ~[r(1)];
     let k = i + j;
-    info!("{}", j);
+    println!("{}", j);
 }
diff --git a/src/test/run-fail/binop-fail-2.rs b/src/test/run-fail/binop-fail-2.rs
index ef2a4e5335f..96918cfc6f7 100644
--- a/src/test/run-fail/binop-fail-2.rs
+++ b/src/test/run-fail/binop-fail-2.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn my_err(s: ~str) -> ! { error!("{}", s); fail!("quux"); }
+fn my_err(s: ~str) -> ! { println!("{}", 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 ef2a4e5335f..96918cfc6f7 100644
--- a/src/test/run-fail/binop-fail.rs
+++ b/src/test/run-fail/binop-fail.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn my_err(s: ~str) -> ! { error!("{}", s); fail!("quux"); }
+fn my_err(s: ~str) -> ! { println!("{}", s); fail!("quux"); }
 fn main() { 3u == my_err(~"bye"); }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
index 0541dcca64d..daec43ea993 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
@@ -22,8 +22,8 @@ fn main() {
     // wrap around to a small number.
 
     let idx = uint::MAX & !(uint::MAX >> 1u);
-    error!("ov2 idx = 0x%x", idx);
+    println!("ov2 idx = 0x%x", idx);
 
     // This should fail.
-    error!("ov2 0x%x",  x[idx]);
+    println!("ov2 0x%x",  x[idx]);
 }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
index c95d128c085..e262d088ba0 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
@@ -24,17 +24,17 @@ fn main() {
     // This test is only meaningful on 32-bit hosts.
 
     let idx = u64::MAX & !(u64::MAX >> 1u);
-    error!("ov3 idx = 0x%8.8x%8.8x",
+    println!("ov3 idx = 0x%8.8x%8.8x",
            (idx >> 32) as uint,
            idx as uint);
 
     // This should fail.
-    error!("ov3 0x%x",  x[idx]);
+    println!("ov3 0x%x",  x[idx]);
 }
 
 #[cfg(target_arch="x86_64")]
 fn main() {
     // This version just fails anyways, for symmetry on 64-bit hosts.
     let x = ~[1u,2u,3u];
-    error!("ov3 0x%x",  x[200]);
+    println!("ov3 0x%x",  x[200]);
 }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
index 932b9a0d451..152f90f9740 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
@@ -24,12 +24,12 @@ fn main() {
 
     let base = x.as_ptr() as uint;
     let idx = base / mem::size_of::<uint>();
-    error!("ov1 base = 0x{:x}", base);
-    error!("ov1 idx = 0x{:x}", idx);
-    error!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
-    error!("ov1 idx * sizeof::<uint>() = 0x{:x}",
+    println!("ov1 base = 0x{:x}", base);
+    println!("ov1 idx = 0x{:x}", idx);
+    println!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
+    println!("ov1 idx * sizeof::<uint>() = 0x{:x}",
            idx * mem::size_of::<uint>());
 
     // This should fail.
-    error!("ov1 0x{:x}",  x[idx]);
+    println!("ov1 0x{:x}",  x[idx]);
 }
diff --git a/src/test/run-fail/extern-fail.rs b/src/test/run-fail/extern-fail.rs
index 06369ba805d..93f55261574 100644
--- a/src/test/run-fail/extern-fail.rs
+++ b/src/test/run-fail/extern-fail.rs
@@ -44,7 +44,7 @@ fn main() {
     for _ in range(0, 10u) {
         task::spawn(proc() {
             let result = count(5u);
-            info!("result = %?", result);
+            println!("result = %?", result);
             fail!();
         });
     }
diff --git a/src/test/run-fail/fail-arg.rs b/src/test/run-fail/fail-arg.rs
index 705b7f4028c..e23145ec253 100644
--- a/src/test/run-fail/fail-arg.rs
+++ b/src/test/run-fail/fail-arg.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 // error-pattern:woe
-fn f(a: int) { info!("{}", a); }
+fn f(a: int) { println!("{}", a); }
 
 fn main() { f(fail!("woe")); }
diff --git a/src/test/run-fail/if-check-fail.rs b/src/test/run-fail/if-check-fail.rs
index d9e64fecfd4..b5f39e73fcb 100644
--- a/src/test/run-fail/if-check-fail.rs
+++ b/src/test/run-fail/if-check-fail.rs
@@ -17,7 +17,7 @@ fn even(x: uint) -> bool {
 
 fn foo(x: uint) {
     if even(x) {
-        info!("{}", x);
+        println!("{}", 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 97c4279b188..583a5c2010a 100644
--- a/src/test/run-fail/if-cond-bot.rs
+++ b/src/test/run-fail/if-cond-bot.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn my_err(s: ~str) -> ! { error!("{}", s); fail!("quux"); }
+fn my_err(s: ~str) -> ! { println!("{}", s); fail!("quux"); }
 fn main() { if my_err(~"bye") { } }
diff --git a/src/test/run-fail/match-wildcards.rs b/src/test/run-fail/match-wildcards.rs
index 0d1aebc82e9..a4a6739bfc1 100644
--- a/src/test/run-fail/match-wildcards.rs
+++ b/src/test/run-fail/match-wildcards.rs
@@ -17,4 +17,4 @@ fn cmp() -> int {
     }
 }
 
-fn main() { error!("{}", cmp()); }
+fn main() { println!("{}", cmp()); }
diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs
index a41ab53964b..06cba673b34 100644
--- a/src/test/run-fail/result-get-fail.rs
+++ b/src/test/run-fail/result-get-fail.rs
@@ -13,5 +13,5 @@
 use std::result;
 
 fn main() {
-    error!("{:?}", result::Err::<int,~str>(~"kitty").unwrap());
+    println!("{:?}", result::Err::<int,~str>(~"kitty").unwrap());
 }
diff --git a/src/test/run-fail/rt-set-exit-status-fail.rs b/src/test/run-fail/rt-set-exit-status-fail.rs
index 7bc5c87c866..98d7d5cf437 100644
--- a/src/test/run-fail/rt-set-exit-status-fail.rs
+++ b/src/test/run-fail/rt-set-exit-status-fail.rs
@@ -10,6 +10,8 @@
 
 // error-pattern:whatever
 
+#[feature(phase)];
+#[phase(syntax, link)] extern crate log;
 use std::os;
 
 fn main() {
diff --git a/src/test/run-fail/rt-set-exit-status-fail2.rs b/src/test/run-fail/rt-set-exit-status-fail2.rs
index d19788d8b5b..67f9f5a168f 100644
--- a/src/test/run-fail/rt-set-exit-status-fail2.rs
+++ b/src/test/run-fail/rt-set-exit-status-fail2.rs
@@ -10,6 +10,8 @@
 
 // error-pattern:whatever
 
+#[feature(phase)];
+#[phase(syntax, link)] extern crate log;
 use std::os;
 use std::task;
 
diff --git a/src/test/run-fail/rt-set-exit-status.rs b/src/test/run-fail/rt-set-exit-status.rs
index 915e9010b3e..352e0f65644 100644
--- a/src/test/run-fail/rt-set-exit-status.rs
+++ b/src/test/run-fail/rt-set-exit-status.rs
@@ -10,6 +10,8 @@
 
 // error-pattern:whatever
 
+#[feature(phase)];
+#[phase(syntax, link)] extern crate log;
 use std::os;
 
 fn main() {
diff --git a/src/test/run-fail/too-much-recursion-unwinding.rs b/src/test/run-fail/too-much-recursion-unwinding.rs
index f9383b9964b..04733552969 100644
--- a/src/test/run-fail/too-much-recursion-unwinding.rs
+++ b/src/test/run-fail/too-much-recursion-unwinding.rs
@@ -15,7 +15,7 @@
 // during unwinding
 
 fn recurse() {
-    info!("don't optimize me out");
+    println!("don't optimize me out");
     recurse();
 }
 
diff --git a/src/test/run-fail/unwind-box-fn-unique.rs b/src/test/run-fail/unwind-box-fn-unique.rs
index 190d3f17543..a49760f3c58 100644
--- a/src/test/run-fail/unwind-box-fn-unique.rs
+++ b/src/test/run-fail/unwind-box-fn-unique.rs
@@ -19,8 +19,8 @@ fn failfn() {
 fn main() {
     let y = ~0;
     let x: @proc() = @(proc() {
-        error!("{:?}", y.clone());
+        println!("{:?}", y.clone());
     });
     failfn();
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-box-res.rs b/src/test/run-fail/unwind-box-res.rs
index 6740331d2f0..49bcde75594 100644
--- a/src/test/run-fail/unwind-box-res.rs
+++ b/src/test/run-fail/unwind-box-res.rs
@@ -43,6 +43,6 @@ fn main() {
         cast::forget(i1);
         let x = @r(i1p);
         failfn();
-        error!("{:?}", x);
+        println!("{:?}", x);
     }
 }
diff --git a/src/test/run-fail/unwind-box-str.rs b/src/test/run-fail/unwind-box-str.rs
index 410b86d5714..6343b81fd2a 100644
--- a/src/test/run-fail/unwind-box-str.rs
+++ b/src/test/run-fail/unwind-box-str.rs
@@ -19,5 +19,5 @@ fn failfn() {
 fn main() {
     let x = @~"hi";
     failfn();
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-box-unique-unique.rs b/src/test/run-fail/unwind-box-unique-unique.rs
index c4747c6089e..d9f425403eb 100644
--- a/src/test/run-fail/unwind-box-unique-unique.rs
+++ b/src/test/run-fail/unwind-box-unique-unique.rs
@@ -19,5 +19,5 @@ fn failfn() {
 fn main() {
     let x = @~~0;
     failfn();
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-box-unique.rs b/src/test/run-fail/unwind-box-unique.rs
index e99c050d16a..045ffea0fcd 100644
--- a/src/test/run-fail/unwind-box-unique.rs
+++ b/src/test/run-fail/unwind-box-unique.rs
@@ -19,5 +19,5 @@ fn failfn() {
 fn main() {
     let x = @~0;
     failfn();
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-box-vec.rs b/src/test/run-fail/unwind-box-vec.rs
index 4a5cd270116..957b631abd3 100644
--- a/src/test/run-fail/unwind-box-vec.rs
+++ b/src/test/run-fail/unwind-box-vec.rs
@@ -19,5 +19,5 @@ fn failfn() {
 fn main() {
     let x = @~[0, 1, 2, 3, 4, 5];
     failfn();
-    error!("{:?}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-make/c-set-crate-map-manually/lib.rs b/src/test/run-make/c-set-crate-map-manually/lib.rs
index 15b0a9140cf..d5bada4a127 100644
--- a/src/test/run-make/c-set-crate-map-manually/lib.rs
+++ b/src/test/run-make/c-set-crate-map-manually/lib.rs
@@ -11,9 +11,11 @@
 #[crate_id="boot#0.1"];
 #[crate_type="dylib"];
 #[no_uv];
+#[feature(phase)];
 
 extern crate rustuv;
 extern crate green;
+#[phase(syntax, link)] extern crate log;
 
 use std::rt::crate_map::{CrateMap, rust_set_crate_map};
 
@@ -24,7 +26,7 @@ pub static set_crate_map: extern "C" fn(*CrateMap<'static>) = rust_set_crate_map
 #[no_mangle] // this needs to get called from C
 pub extern "C" fn foo(argc: int, argv: **u8) -> int {
     green::start(argc, argv, proc() {
-        if log_enabled!(std::logging::DEBUG) { return }
+        if log_enabled!(log::DEBUG) { return }
         fail!()
     })
 }
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 9a37af1e125..1c797d8369f 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -83,7 +83,7 @@ fn check_pp<T>(cx: fake_ext_ctxt,
     });
     stdout().write_line(s);
     if expect != ~"" {
-        error!("expect: '%s', got: '%s'", expect, s);
+        println!("expect: '%s', got: '%s'", expect, s);
         assert_eq!(s, expect);
     }
 }
diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs
index 5683a2b6698..a0233360a7c 100644
--- a/src/test/run-pass/alignment-gep-tup-like-1.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-1.rs
@@ -36,7 +36,7 @@ fn f<A:Clone + 'static>(a: A, b: u16) -> ~Invokable:<A> {
 
 pub fn main() {
     let (a, b) = f(22_u64, 44u16).f();
-    info!("a={:?} b={:?}", a, b);
+    println!("a={:?} b={:?}", a, b);
     assert_eq!(a, 22u64);
     assert_eq!(b, 44u16);
 }
diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs
index 5cbd0da23cf..24c63e5affc 100644
--- a/src/test/run-pass/arith-0.rs
+++ b/src/test/run-pass/arith-0.rs
@@ -12,6 +12,6 @@
 
 pub fn main() {
     let a: int = 10;
-    info!("{}", a);
+    println!("{}", a);
     assert_eq!(a * (a - 1), 90);
 }
diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs
index 0b3492784c8..e834aa5aa09 100644
--- a/src/test/run-pass/arith-1.rs
+++ b/src/test/run-pass/arith-1.rs
@@ -28,6 +28,6 @@ pub fn main() {
     assert_eq!(i32_b << 1, i32_b << 1);
     assert_eq!(i32_b >> 1, i32_b >> 1);
     assert_eq!(i32_b & i32_b << 1, 0);
-    info!("{}", i32_b | i32_b << 1);
+    println!("{}", i32_b | i32_b << 1);
     assert_eq!(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 a4b6d33fb79..c2b276aac09 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -18,6 +18,6 @@ struct Triple { x: int, y: int, z: int }
 fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
 
 pub fn main() {
-    info!("{:?}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
-    info!("{:?}", f(5, 6).a);
+    println!("{:?}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
+    println!("{:?}", f(5, 6).a);
 }
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 233509a8cd2..3e3d9aab84e 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -81,7 +81,7 @@ fn test_class() {
   let mut r = p(1, 2);
 
   unsafe {
-  error!("q = {:x}, r = {:x}",
+  println!("q = {:x}, r = {:x}",
          (::std::cast::transmute::<*p, uint>(&q)),
          (::std::cast::transmute::<*p, uint>(&r)));
   }
diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs
index 61e36d2d720..d359f488ca5 100644
--- a/src/test/run-pass/bitwise.rs
+++ b/src/test/run-pass/bitwise.rs
@@ -26,8 +26,8 @@ fn general() {
     a ^= b;
     b ^= a;
     a = a ^ b;
-    info!("{}", a);
-    info!("{}", b);
+    println!("{}", a);
+    println!("{}", b);
     assert_eq!(b, 1);
     assert_eq!(a, 2);
     assert_eq!(!0xf0 & 0xff, 0xf);
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index d59804b2395..1957992e03d 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -22,7 +22,7 @@ pub fn main() {
 
     // Statement form does not require parentheses:
     for i in v.iter() {
-        info!("{:?}", *i);
+        println!("{:?}", *i);
     }
 
 }
diff --git a/src/test/run-pass/block-explicit-types.rs b/src/test/run-pass/block-explicit-types.rs
index 82e563ae41c..2fb9bb9edfc 100644
--- a/src/test/run-pass/block-explicit-types.rs
+++ b/src/test/run-pass/block-explicit-types.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     fn as_buf<T>(s: ~str, f: |~str| -> T) -> T { f(s) }
-    as_buf(~"foo", |foo: ~str| -> () error!("{}", foo) );
+    as_buf(~"foo", |foo: ~str| -> () println!("{}", foo) );
 }
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index 4aebcd6aa24..f14d42e17f3 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -20,6 +20,6 @@ pub fn main() {
             odds += 1;
         }
     });
-    error!("{:?}", odds);
+    println!("{:?}", odds);
     assert_eq!(odds, 4);
 }
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 2e149f88478..deabead4876 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -20,6 +20,6 @@ pub fn main() {
             sum += *i * *j;
         });
     });
-    error!("{:?}", sum);
+    println!("{:?}", sum);
     assert_eq!(sum, 225);
 }
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index 10760236e6d..d90087ebdea 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -31,9 +31,9 @@ pub fn main() {
     add_int(ints, 44);
 
     iter_ints(ints, |i| {
-        error!("int = {}", *i);
+        println!("int = {}", *i);
         true
     });
 
-    error!("ints={:?}", ints);
+    println!("ints={:?}", ints);
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 5cdda81c436..e9248864c02 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -30,7 +30,7 @@ pub fn main() {
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         x = @F {f: ~4};
 
-        info!("&*b_x = {:p}", &(*b_x));
+        println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
         assert!(&(*x.f) as *int != &(*b_x) as *int);
     })
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index 3050d6fa011..6f6d8eba9c0 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -30,7 +30,7 @@ pub fn main() {
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         *x = @F{f: ~4};
 
-        info!("&*b_x = {:p}", &(*b_x));
+        println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
         assert!(&(*x.f) as *int != &(*b_x) as *int);
     })
diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs
index 76dfbffc09c..cd2bfee700a 100644
--- a/src/test/run-pass/borrowck-preserve-box.rs
+++ b/src/test/run-pass/borrowck-preserve-box.rs
@@ -28,7 +28,7 @@ pub fn main() {
         assert_eq!(&(*x) as *int, &(*b_x) as *int);
         x = @22;
 
-        info!("&*b_x = {:p}", &(*b_x));
+        println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
         assert!(&(*x) as *int != &(*b_x) as *int);
     })
diff --git a/src/test/run-pass/borrowck-preserve-cond-box.rs b/src/test/run-pass/borrowck-preserve-cond-box.rs
index 57365e98f97..7c8008b1b3f 100644
--- a/src/test/run-pass/borrowck-preserve-cond-box.rs
+++ b/src/test/run-pass/borrowck-preserve-cond-box.rs
@@ -27,13 +27,13 @@ fn testfn(cond: bool) {
         exp = 4;
     }
 
-    info!("*r = {}, exp = {}", *r, exp);
+    println!("*r = {}, exp = {}", *r, exp);
     assert_eq!(*r, exp);
 
     x = @5;
     y = @6;
 
-    info!("*r = {}, exp = {}", *r, exp);
+    println!("*r = {}, exp = {}", *r, exp);
     assert_eq!(*r, exp);
     assert_eq!(x, @5);
     assert_eq!(y, @6);
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index 00e59f5132d..fda6bcc90c9 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -30,7 +30,7 @@ pub fn main() {
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         x = @F {f: ~4};
 
-        info!("&*b_x = {:p}", &(*b_x));
+        println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
         assert!(&(*x.f) as *int != &(*b_x) as *int);
     })
diff --git a/src/test/run-pass/box-inside-if.rs b/src/test/run-pass/box-inside-if.rs
index baec382f3ca..1e003e1cb9e 100644
--- a/src/test/run-pass/box-inside-if.rs
+++ b/src/test/run-pass/box-inside-if.rs
@@ -17,7 +17,7 @@ fn is_odd(_n: int) -> bool { return true; }
 fn length_is_even(_vs: @int) -> bool { return true; }
 
 fn foo(_acc: int, n: int) {
-    if is_odd(n) && length_is_even(some_box(1)) { error!("bloop"); }
+    if is_odd(n) && length_is_even(some_box(1)) { println!("bloop"); }
 }
 
 pub fn main() { foo(67, 5); }
diff --git a/src/test/run-pass/box-inside-if2.rs b/src/test/run-pass/box-inside-if2.rs
index acc494a5665..8f3f254dfe9 100644
--- a/src/test/run-pass/box-inside-if2.rs
+++ b/src/test/run-pass/box-inside-if2.rs
@@ -17,7 +17,7 @@ fn is_odd(_n: int) -> bool { return true; }
 fn length_is_even(_vs: @int) -> bool { return true; }
 
 fn foo(_acc: int, n: int) {
-    if is_odd(n) || length_is_even(some_box(1)) { error!("bloop"); }
+    if is_odd(n) || length_is_even(some_box(1)) { println!("bloop"); }
 }
 
 pub fn main() { foo(67, 5); }
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index a5ba89271c4..59050a64f68 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -17,6 +17,6 @@ fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); }
 pub fn main() {
     let foo: int = 17;
     let bfoo: Box<int> = Box {c: @foo};
-    info!("see what's in our box");
+    println!("see what's in our box");
     assert_eq!(unbox::<int>(bfoo), foo);
 }
diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs
index ae98695cf75..b1db8ad9223 100644
--- a/src/test/run-pass/capturing-logging.rs
+++ b/src/test/run-pass/capturing-logging.rs
@@ -12,12 +12,16 @@
 // ignore-android (FIXME #11419)
 // exec-env:RUST_LOG=info
 
+#[feature(phase)];
+
 #[no_uv];
 extern crate native;
+#[phase(syntax, link)]
+extern crate log;
 
 use std::fmt;
 use std::io::{ChanReader, ChanWriter};
-use std::logging::{set_logger, Logger};
+use log::{set_logger, Logger};
 
 struct MyWriter(ChanWriter);
 
diff --git a/src/test/run-pass/cast-region-to-uint.rs b/src/test/run-pass/cast-region-to-uint.rs
index a831cd1da69..eacdd8f3978 100644
--- a/src/test/run-pass/cast-region-to-uint.rs
+++ b/src/test/run-pass/cast-region-to-uint.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let x = 3;
-    info!("&x={:x}", (&x as *int as uint));
+    println!("&x={:x}", (&x as *int as uint));
 }
diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs
index cb77c63d451..b276c8a8b07 100644
--- a/src/test/run-pass/cci_borrow.rs
+++ b/src/test/run-pass/cci_borrow.rs
@@ -19,6 +19,6 @@ use cci_borrow_lib::foo;
 pub fn main() {
     let p = @22u;
     let r = foo(p);
-    info!("r={}", r);
+    println!("r={}", r);
     assert_eq!(r, 22u);
 }
diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs
index e5e1736044c..ee01849e7e7 100644
--- a/src/test/run-pass/cci_impl_exe.rs
+++ b/src/test/run-pass/cci_impl_exe.rs
@@ -16,13 +16,13 @@ use cci_impl_lib::uint_helpers;
 
 pub fn main() {
     //let bt0 = sys::frame_address();
-    //info!("%?", bt0);
+    //println!("%?", bt0);
 
     3u.to(10u, |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
-        //info!("%?", bt1);
+        //println!("%?", bt1);
         //assert!(bt0 == bt1);
     })
 }
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index 41717177f75..4a5770b3c6c 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -15,7 +15,7 @@ extern crate cci_iter_lib;
 
 pub fn main() {
     //let bt0 = sys::rusti::frame_address(1u32);
-    //info!("%?", bt0);
+    //println!("%?", bt0);
     cci_iter_lib::iter([1, 2, 3], |i| {
         println!("{}", *i);
         //assert!(bt0 == sys::rusti::frame_address(2u32));
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index faa2a350117..bd18acedbff 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -21,12 +21,12 @@ pub fn main() {
     // sys::frame_address() to determine if we are inlining is
     // actually working.
     //let bt0 = sys::frame_address();
-    //info!("%?", bt0);
+    //println!("%?", bt0);
     iter(~[1u, 2u, 3u], |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
-        //info!("%?", bt1);
+        //println!("%?", bt1);
 
         //assert!(bt0 != bt1);
     })
diff --git a/src/test/run-pass/class-attributes-1.rs b/src/test/run-pass/class-attributes-1.rs
index 97b3eda5eff..f4c95c5b232 100644
--- a/src/test/run-pass/class-attributes-1.rs
+++ b/src/test/run-pass/class-attributes-1.rs
@@ -16,7 +16,7 @@ struct cat {
 
 impl Drop for cat {
     #[cat_dropper]
-    fn drop(&mut self) { error!("{} landed on hir feet" , self . name); }
+    fn drop(&mut self) { println!("{} landed on hir feet" , self . name); }
 }
 
 
diff --git a/src/test/run-pass/class-attributes-2.rs b/src/test/run-pass/class-attributes-2.rs
index fa498e90503..c4dc0ac7412 100644
--- a/src/test/run-pass/class-attributes-2.rs
+++ b/src/test/run-pass/class-attributes-2.rs
@@ -18,7 +18,7 @@ impl Drop for cat {
        Actually, cats don't always land on their feet when you drop them.
     */
     fn drop(&mut self) {
-        error!("{} landed on hir feet", self.name);
+        println!("{} landed on hir feet", self.name);
     }
 }
 
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 746342ae973..a9a11361f9b 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -16,7 +16,7 @@ use cci_class_cast::kitty::cat;
 
 fn print_out(thing: ~ToStr, expected: ~str) {
   let actual = thing.to_str();
-  info!("{}", actual);
+  println!("{}", actual);
   assert_eq!(actual, expected);
 }
 
diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
index 10b0ac375a9..cdf235b113e 100644
--- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs
+++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
@@ -22,7 +22,7 @@ struct dog {
 
 impl dog {
     fn bark(&mut self) -> int {
-      info!("Woof {} {}", self.barks, self.volume);
+      println!("Woof {} {}", self.barks, self.volume);
       self.barks += 1u;
       if self.barks % 3u == 0u {
           self.volume += 1;
@@ -30,7 +30,7 @@ impl dog {
       if self.barks % 10u == 0u {
           self.volume -= 2;
       }
-      info!("Grrr {} {}", self.barks, self.volume);
+      println!("Grrr {} {}", self.barks, self.volume);
       self.volume
     }
 }
@@ -70,7 +70,7 @@ impl cat {
 
 impl cat {
     fn meow(&mut self) -> uint {
-        info!("Meow");
+        println!("Meow");
         self.meows += 1u;
         if self.meows % 5u == 0u {
             self.how_hungry += 1;
diff --git a/src/test/run-pass/class-cast-to-trait.rs b/src/test/run-pass/class-cast-to-trait.rs
index 56b61dc5691..b57851ea3cf 100644
--- a/src/test/run-pass/class-cast-to-trait.rs
+++ b/src/test/run-pass/class-cast-to-trait.rs
@@ -27,12 +27,12 @@ impl noisy for cat {
 impl cat {
   pub fn eat(&mut self) -> bool {
     if self.how_hungry > 0 {
-        error!("OM NOM NOM");
+        println!("OM NOM NOM");
         self.how_hungry -= 2;
         return true;
     }
     else {
-        error!("Not hungry!");
+        println!("Not hungry!");
         return false;
     }
   }
@@ -40,7 +40,7 @@ impl cat {
 
 impl cat {
     fn meow(&mut self) {
-      error!("Meow");
+      println!("Meow");
       self.meows += 1u;
       if self.meows % 5u == 0u {
           self.how_hungry += 1;
diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs
index b9288a67f96..e70341612df 100644
--- a/src/test/run-pass/class-impl-very-parameterized-trait.rs
+++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs
@@ -39,11 +39,11 @@ impl<T> cat<T> {
 
     pub fn eat(&mut self) -> bool {
         if self.how_hungry > 0 {
-            error!("OM NOM NOM");
+            println!("OM NOM NOM");
             self.how_hungry -= 2;
             return true;
         } else {
-            error!("Not hungry!");
+            println!("Not hungry!");
             return false;
         }
     }
@@ -107,7 +107,7 @@ impl<T> cat<T> {
 impl<T> cat<T> {
     fn meow(&mut self) {
         self.meows += 1;
-        error!("Meow {}", self.meows);
+        println!("Meow {}", self.meows);
         if self.meows % 5 == 0 {
             self.how_hungry += 1;
         }
diff --git a/src/test/run-pass/class-implement-trait-cross-crate.rs b/src/test/run-pass/class-implement-trait-cross-crate.rs
index caa4a3b2feb..1b4a9fbd099 100644
--- a/src/test/run-pass/class-implement-trait-cross-crate.rs
+++ b/src/test/run-pass/class-implement-trait-cross-crate.rs
@@ -23,12 +23,12 @@ struct cat {
 impl cat {
     pub fn eat(&mut self) -> bool {
         if self.how_hungry > 0 {
-            error!("OM NOM NOM");
+            println!("OM NOM NOM");
             self.how_hungry -= 2;
             return true;
         }
         else {
-            error!("Not hungry!");
+            println!("Not hungry!");
             return false;
         }
     }
@@ -40,7 +40,7 @@ impl noisy for cat {
 
 impl cat {
     fn meow(&mut self) {
-        error!("Meow");
+        println!("Meow");
         self.meows += 1u;
         if self.meows % 5u == 0u {
             self.how_hungry += 1;
diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs
index dbd34f35e27..d967310b907 100644
--- a/src/test/run-pass/class-implement-traits.rs
+++ b/src/test/run-pass/class-implement-traits.rs
@@ -24,7 +24,7 @@ struct cat {
 
 impl cat {
     fn meow(&mut self) {
-        error!("Meow");
+        println!("Meow");
         self.meows += 1u;
         if self.meows % 5u == 0u {
             self.how_hungry += 1;
@@ -35,11 +35,11 @@ impl cat {
 impl cat {
     pub fn eat(&mut self) -> bool {
         if self.how_hungry > 0 {
-            error!("OM NOM NOM");
+            println!("OM NOM NOM");
             self.how_hungry -= 2;
             return true;
         } else {
-            error!("Not hungry!");
+            println!("Not hungry!");
             return false;
         }
     }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 55fa783391a..a93f7c9d73b 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -24,12 +24,12 @@ impl cat {
 
     pub fn eat(&mut self) -> bool {
         if self.how_hungry > 0 {
-            error!("OM NOM NOM");
+            println!("OM NOM NOM");
             self.how_hungry -= 2;
             return true;
         }
         else {
-            error!("Not hungry!");
+            println!("Not hungry!");
             return false;
         }
     }
@@ -37,7 +37,7 @@ impl cat {
 
 impl cat {
     fn meow(&mut self) {
-        error!("Meow");
+        println!("Meow");
         self.meows += 1u;
         if self.meows % 5u == 0u {
             self.how_hungry += 1;
@@ -61,7 +61,7 @@ impl fmt::Show for cat {
 
 fn print_out(thing: ~ToStr, expected: ~str) {
   let actual = thing.to_str();
-  info!("{}", actual);
+  println!("{}", actual);
   assert_eq!(actual, expected);
 }
 
diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs
index f65bf329823..26708e8f8a2 100644
--- a/src/test/run-pass/classes.rs
+++ b/src/test/run-pass/classes.rs
@@ -20,11 +20,11 @@ impl cat {
 
     pub fn eat(&mut self) -> bool {
         if self.how_hungry > 0 {
-            error!("OM NOM NOM");
+            println!("OM NOM NOM");
             self.how_hungry -= 2;
             return true;
         } else {
-            error!("Not hungry!");
+            println!("Not hungry!");
             return false;
         }
     }
@@ -32,7 +32,7 @@ impl cat {
 
 impl cat {
     fn meow(&mut self) {
-        error!("Meow");
+        println!("Meow");
         self.meows += 1u;
         if self.meows % 5u == 0u {
             self.how_hungry += 1;
diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs
index 6ba665e4005..ea75ae2fc5c 100644
--- a/src/test/run-pass/close-over-big-then-small-data.rs
+++ b/src/test/run-pass/close-over-big-then-small-data.rs
@@ -40,7 +40,7 @@ fn f<A:Clone + 'static>(a: A, b: u16) -> ~Invokable:<A> {
 
 pub fn main() {
     let (a, b) = f(22_u64, 44u16).f();
-    info!("a={:?} b={:?}", a, b);
+    println!("a={:?} b={:?}", a, b);
     assert_eq!(a, 22u64);
     assert_eq!(b, 44u16);
 }
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index ad6c92c4925..ae21d53b7e0 100644
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -14,13 +14,13 @@ pub fn main() {
     let (tx, rx) = channel();
     let _t = task::spawn(proc() { child(&tx) });
     let y = rx.recv();
-    error!("received");
-    error!("{:?}", y);
+    println!("received");
+    println!("{:?}", y);
     assert_eq!(y, 10);
 }
 
 fn child(c: &Sender<int>) {
     error!("sending");
     c.send(10);
-    error!("value sent");
+    println!("value sent");
 }
diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs
index 8ce7cb14042..cad7f05171a 100644
--- a/src/test/run-pass/complex.rs
+++ b/src/test/run-pass/complex.rs
@@ -36,7 +36,7 @@ fn foo(x: int) -> int {
 
 pub fn main() {
     let x: int = 2 + 2;
-    info!("{}", x);
-    info!("hello, world");
-    info!("{}", 10);
+    println!("{}", x);
+    println!("hello, world");
+    println!("{}", 10);
 }
diff --git a/src/test/run-pass/conditional-debug-macro-off.rs b/src/test/run-pass/conditional-debug-macro-off.rs
index 562629053cb..8a2a00f5638 100644
--- a/src/test/run-pass/conditional-debug-macro-off.rs
+++ b/src/test/run-pass/conditional-debug-macro-off.rs
@@ -12,7 +12,11 @@
 // compile-flags: --cfg ndebug
 // exec-env:RUST_LOG=conditional-debug-macro-off=4
 
+#[feature(phase)];
+#[phase(syntax, link)]
+extern crate log;
+
 pub fn main() {
-    // only fails if debug! evaluates its argument.
+    // only fails if println! evaluates its argument.
     debug!("{:?}", { if true { fail!() } });
 }
diff --git a/src/test/run-pass/conditional-debug-macro-on.rs b/src/test/run-pass/conditional-debug-macro-on.rs
index a934a0f6688..324f1aade04 100644
--- a/src/test/run-pass/conditional-debug-macro-on.rs
+++ b/src/test/run-pass/conditional-debug-macro-on.rs
@@ -12,9 +12,9 @@
 // exec-env:RUST_LOG=conditional-debug-macro-on=4
 
 pub fn main() {
-    // exits early if debug! evaluates its arguments, otherwise it
+    // exits early if println! evaluates its arguments, otherwise it
     // will hit the fail.
-    debug!("{:?}", { if true { return; } });
+    println!("{:?}", { if true { return; } });
 
     fail!();
 }
diff --git a/src/test/run-pass/const.rs b/src/test/run-pass/const.rs
index fe060ff482e..8f78d54c701 100644
--- a/src/test/run-pass/const.rs
+++ b/src/test/run-pass/const.rs
@@ -12,4 +12,4 @@
 
 static i: int = 10;
 
-pub fn main() { info!("{}", i); }
+pub fn main() { println!("{}", i); }
diff --git a/src/test/run-pass/dead-code-one-arm-if.rs b/src/test/run-pass/dead-code-one-arm-if.rs
index da5c692d212..23c143445ab 100644
--- a/src/test/run-pass/dead-code-one-arm-if.rs
+++ b/src/test/run-pass/dead-code-one-arm-if.rs
@@ -11,4 +11,4 @@
 
 
 
-pub fn main() { if 1 == 1 { return; } info!("Paul is dead"); }
+pub fn main() { if 1 == 1 { return; } println!("Paul is dead"); }
diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs
index 914805c126f..6bac1511d55 100644
--- a/src/test/run-pass/deref-lval.rs
+++ b/src/test/run-pass/deref-lval.rs
@@ -15,5 +15,5 @@ use std::cell::Cell;
 pub fn main() {
     let x = @Cell::new(5);
     x.set(1000);
-    info!("{:?}", x.get());
+    println!("{:?}", x.get());
 }
diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs
index f579e7a3d20..2d33ac4e5de 100644
--- a/src/test/run-pass/estr-slice.rs
+++ b/src/test/run-pass/estr-slice.rs
@@ -14,8 +14,8 @@ pub fn main() {
     let v = &"hello";
     let y : &str = &"there";
 
-    info!("{}", x);
-    info!("{}", y);
+    println!("{}", x);
+    println!("{}", y);
 
     assert_eq!(x[0], 'h' as u8);
     assert_eq!(x[4], 'o' as u8);
@@ -30,7 +30,7 @@ pub fn main() {
     let c = &"cccc";
     let cc = &"ccccc";
 
-    info!("{}", a);
+    println!("{}", a);
 
     assert!(a < b);
     assert!(a <= b);
@@ -38,7 +38,7 @@ pub fn main() {
     assert!(b >= a);
     assert!(b > a);
 
-    info!("{}", b);
+    println!("{}", b);
 
     assert!(a < c);
     assert!(a <= c);
@@ -46,7 +46,7 @@ pub fn main() {
     assert!(c >= a);
     assert!(c > a);
 
-    info!("{}", c);
+    println!("{}", c);
 
     assert!(c < cc);
     assert!(c <= cc);
@@ -54,5 +54,5 @@ pub fn main() {
     assert!(cc >= c);
     assert!(cc > c);
 
-    info!("{}", cc);
+    println!("{}", cc);
 }
diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs
index a0af5e5a9e0..aaa3e3529d4 100644
--- a/src/test/run-pass/evec-slice.rs
+++ b/src/test/run-pass/evec-slice.rs
@@ -22,7 +22,7 @@ pub fn main() {
     let c : &[int] = &[2,2,2,2,3];
     let cc : &[int] = &[2,2,2,2,2,2];
 
-    info!("{:?}", a);
+    println!("{:?}", a);
 
     assert!(a < b);
     assert!(a <= b);
@@ -30,7 +30,7 @@ pub fn main() {
     assert!(b >= a);
     assert!(b > a);
 
-    info!("{:?}", b);
+    println!("{:?}", b);
 
     assert!(b < c);
     assert!(b <= c);
@@ -44,7 +44,7 @@ pub fn main() {
     assert!(c >= a);
     assert!(c > a);
 
-    info!("{:?}", c);
+    println!("{:?}", c);
 
     assert!(a < cc);
     assert!(a <= cc);
@@ -52,5 +52,5 @@ pub fn main() {
     assert!(cc >= a);
     assert!(cc > a);
 
-    info!("{:?}", cc);
+    println!("{:?}", cc);
 }
diff --git a/src/test/run-pass/export-non-interference2.rs b/src/test/run-pass/export-non-interference2.rs
index 13b21fbe1af..0b9b8fbcfd3 100644
--- a/src/test/run-pass/export-non-interference2.rs
+++ b/src/test/run-pass/export-non-interference2.rs
@@ -13,7 +13,7 @@ mod foo {
         pub fn y() { super::super::foo::x(); }
     }
 
-    pub fn x() { info!("x"); }
+    pub fn x() { println!("x"); }
 }
 
 pub fn main() { self::foo::bar::y(); }
diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs
index 85e5534fcf5..a0d97383f0a 100644
--- a/src/test/run-pass/export-non-interference3.rs
+++ b/src/test/run-pass/export-non-interference3.rs
@@ -15,7 +15,7 @@ pub mod foo {
 }
 
 pub mod bar {
-    pub fn x() { info!("x"); }
+    pub fn x() { println!("x"); }
 }
 
 pub fn main() { foo::x(); }
diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs
index f081d13a5b0..eaead09a2f7 100644
--- a/src/test/run-pass/expr-block-generic-box1.rs
+++ b/src/test/run-pass/expr-block-generic-box1.rs
@@ -19,8 +19,8 @@ fn test_generic<T>(expected: @T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool {
-        info!("{}", *b1);
-        info!("{}", *b2);
+        println!("{}", *b1);
+        println!("{}", *b2);
         return *b1 == *b2;
     }
     test_generic::<bool>(@true, 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 43ddfe6d58f..b3fbd8c7658 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -19,8 +19,8 @@ fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: ~bool, b2: ~bool) -> bool {
-        info!("{}", *b1);
-        info!("{}", *b2);
+        println!("{}", *b1);
+        println!("{}", *b2);
         return *b1 == *b2;
     }
     test_generic::<bool>(~true, compare_box);
diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs
index e3b727fafd3..67f2d750cc0 100644
--- a/src/test/run-pass/extern-call-deep.rs
+++ b/src/test/run-pass/extern-call-deep.rs
@@ -31,13 +31,13 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
 
 fn count(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }
 
 pub fn main() {
     let result = count(1000u);
-    info!("result = {}", result);
+    println!("result = {}", result);
     assert_eq!(result, 1000u);
 }
diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs
index 500ae8951ec..701ae33132d 100644
--- a/src/test/run-pass/extern-call-deep2.rs
+++ b/src/test/run-pass/extern-call-deep2.rs
@@ -32,7 +32,7 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
 
 fn count(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }
@@ -42,7 +42,7 @@ pub fn main() {
     // has a large stack)
     task::spawn(proc() {
         let result = count(1000u);
-        info!("result = {}", result);
+        println!("result = {}", result);
         assert_eq!(result, 1000u);
     });
 }
diff --git a/src/test/run-pass/extern-call-indirect.rs b/src/test/run-pass/extern-call-indirect.rs
index c49d589572c..16142b2f896 100644
--- a/src/test/run-pass/extern-call-indirect.rs
+++ b/src/test/run-pass/extern-call-indirect.rs
@@ -31,13 +31,13 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
 
 fn fact(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }
 
 pub fn main() {
     let result = fact(10u);
-    info!("result = {}", result);
+    println!("result = {}", result);
     assert_eq!(result, 3628800u);
 }
diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs
index c35e84154d8..c67810bb17a 100644
--- a/src/test/run-pass/extern-call-scrub.rs
+++ b/src/test/run-pass/extern-call-scrub.rs
@@ -36,7 +36,7 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
 
 fn count(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }
@@ -46,7 +46,7 @@ pub fn main() {
     // has a large stack)
     task::spawn(proc() {
         let result = count(12u);
-        info!("result = {}", result);
+        println!("result = {}", result);
         assert_eq!(result, 2048u);
     });
 }
diff --git a/src/test/run-pass/extern-crosscrate.rs b/src/test/run-pass/extern-crosscrate.rs
index ccd79600a15..43c7887d3ef 100644
--- a/src/test/run-pass/extern-crosscrate.rs
+++ b/src/test/run-pass/extern-crosscrate.rs
@@ -15,13 +15,13 @@ extern crate externcallback = "externcallback#0.1";
 
 fn fact(n: uint) -> uint {
     unsafe {
-        info!("n = {}", n);
+        println!("n = {}", n);
         externcallback::rustrt::rust_dbg_call(externcallback::cb, n)
     }
 }
 
 pub fn main() {
     let result = fact(10u);
-    info!("result = {}", result);
+    println!("result = {}", result);
     assert_eq!(result, 3628800u);
 }
diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs
index d7b8ed583a5..ba4f0ccfe64 100644
--- a/src/test/run-pass/extern-yield.rs
+++ b/src/test/run-pass/extern-yield.rs
@@ -41,7 +41,7 @@ pub fn main() {
     for _ in range(0, 10u) {
         task::spawn(proc() {
             let result = count(5u);
-            info!("result = {}", result);
+            println!("result = {}", result);
             assert_eq!(result, 16u);
         });
     }
diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs
index 2f79784ce54..172ec2f0905 100644
--- a/src/test/run-pass/fact.rs
+++ b/src/test/run-pass/fact.rs
@@ -12,26 +12,26 @@
 
 
 fn f(x: int) -> int {
-    // info!("in f:");
+    // println!("in f:");
 
-    info!("{}", x);
+    println!("{}", x);
     if x == 1 {
-        // info!("bottoming out");
+        // println!("bottoming out");
 
         return 1;
     } else {
-        // info!("recurring");
+        // println!("recurring");
 
         let y: int = x * f(x - 1);
-        // info!("returned");
+        // println!("returned");
 
-        info!("{}", y);
+        println!("{}", y);
         return y;
     }
 }
 
 pub fn main() {
     assert_eq!(f(5), 120);
-    // info!("all done");
+    // println!("all done");
 
 }
diff --git a/src/test/run-pass/fat-arrow-match.rs b/src/test/run-pass/fat-arrow-match.rs
index 973da6eab8d..e29cad9c2a3 100644
--- a/src/test/run-pass/fat-arrow-match.rs
+++ b/src/test/run-pass/fat-arrow-match.rs
@@ -16,7 +16,7 @@ enum color {
 }
 
 pub fn main() {
-    error!("{}", match red {
+    println!("{}", match red {
         red => { 1 }
         green => { 2 }
         blue => { 3 }
diff --git a/src/test/run-pass/float-signature.rs b/src/test/run-pass/float-signature.rs
index 26974bbcece..08daf1bd80e 100644
--- a/src/test/run-pass/float-signature.rs
+++ b/src/test/run-pass/float-signature.rs
@@ -14,5 +14,5 @@ pub fn main() {
     fn foo(n: f64) -> f64 { return n + 0.12345; }
     let n: f64 = 0.1;
     let m: f64 = foo(n);
-    info!("{}", m);
+    println!("{}", m);
 }
diff --git a/src/test/run-pass/float.rs b/src/test/run-pass/float.rs
index 987ee233810..277f0011c1c 100644
--- a/src/test/run-pass/float.rs
+++ b/src/test/run-pass/float.rs
@@ -12,9 +12,9 @@
 
 pub fn main() {
     let pi = 3.1415927;
-    info!("{:?}", -pi * (pi + 2.0 / pi) - pi * 5.0);
+    println!("{:?}", -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 {
-        info!("yes");
+        println!("yes");
     }
 }
diff --git a/src/test/run-pass/fn-bare-item.rs b/src/test/run-pass/fn-bare-item.rs
index e01c7ee998c..455b71aff87 100644
--- a/src/test/run-pass/fn-bare-item.rs
+++ b/src/test/run-pass/fn-bare-item.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn f() {
-    info!("This is a bare function");
+    println!("This is a bare function");
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
index 7011088fa5d..7a728e18a29 100644
--- a/src/test/run-pass/foreach-put-structured.rs
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -21,8 +21,8 @@ pub fn main() {
     let mut j: int = 0;
     pairs(|p| {
         let (_0, _1) = p;
-        info!("{}", _0);
-        info!("{}", _1);
+        println!("{}", _0);
+        println!("{}", _1);
         assert_eq!(_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 81e9ac1b808..bb726773bb5 100644
--- a/src/test/run-pass/foreach-simple-outer-slot.rs
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -13,13 +13,13 @@
 
 pub fn main() {
     let mut sum: int = 0;
-    first_ten(|i| { info!("main"); info!("{}", i); sum = sum + i; });
-    info!("sum");
-    info!("{}", sum);
+    first_ten(|i| { println!("main"); println!("{}", i); sum = sum + i; });
+    println!("sum");
+    println!("{}", sum);
     assert_eq!(sum, 45);
 }
 
 fn first_ten(it: |int|) {
     let mut i: int = 0;
-    while i < 10 { info!("first_ten"); it(i); i = i + 1; }
+    while i < 10 { println!("first_ten"); it(i); i = i + 1; }
 }
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 72427b6c539..9e7344a8dfc 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -15,6 +15,6 @@ fn id<T>(t: T) -> T { return t; }
 pub fn main() {
     let expected = @100;
     let actual = id::<@int>(expected);
-    info!("{:?}", *actual);
+    println!("{:?}", *actual);
     assert_eq!(*expected, *actual);
 }
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index a54c68a907b..898d0c0ec23 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -15,6 +15,6 @@ fn id<T:Send>(t: T) -> T { return t; }
 pub fn main() {
     let expected = ~100;
     let actual = id::<~int>(expected.clone());
-    info!("{:?}", *actual);
+    println!("{:?}", *actual);
     assert_eq!(*expected, *actual);
 }
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index 396ac88bd06..80f64d8df3d 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -25,8 +25,8 @@ fn f<T:Clone>(t: T) -> Pair<T> {
 
 pub fn main() {
     let b = f::<int>(10);
-    info!("{:?}" ,b.a);
-    info!("{:?}", b.b);
+    println!("{:?}" ,b.a);
+    println!("{:?}", b.b);
     assert_eq!(b.a, 10);
     assert_eq!(b.b, 10);
 }
diff --git a/src/test/run-pass/generic-fn-box.rs b/src/test/run-pass/generic-fn-box.rs
index 6eccdb93d8c..9ee237e97f0 100644
--- a/src/test/run-pass/generic-fn-box.rs
+++ b/src/test/run-pass/generic-fn-box.rs
@@ -12,4 +12,4 @@
 
 fn f<T>(x: @T) -> @T { return x; }
 
-pub fn main() { let x = f(@3); info!("{:?}", *x); }
+pub fn main() { let x = f(@3); println!("{:?}", *x); }
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index 64e7d0101b8..c27aff53b67 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -11,4 +11,4 @@
 
 fn f<T>(x: ~T) -> ~T { return x; }
 
-pub fn main() { let x = f(~3); info!("{:?}", *x); }
+pub fn main() { let x = f(~3); println!("{:?}", *x); }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index 27dc4ad8069..13a9d57e578 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -22,14 +22,14 @@ pub fn main() {
     let p: Triple = Triple {x: 65, y: 66, z: 67};
     let mut q: Triple = Triple {x: 68, y: 69, z: 70};
     y = id::<int>(x);
-    info!("{}", y);
+    println!("{}", y);
     assert_eq!(x, y);
     b = id::<char>(a);
-    info!("{}", b);
+    println!("{}", b);
     assert_eq!(a, b);
     q = id::<Triple>(p);
     x = p.z;
     y = q.z;
-    info!("{}", y);
+    println!("{}", y);
     assert_eq!(x, y);
 }
diff --git a/src/test/run-pass/generic-tag-match.rs b/src/test/run-pass/generic-tag-match.rs
index f740d8cb2d1..c20de257315 100644
--- a/src/test/run-pass/generic-tag-match.rs
+++ b/src/test/run-pass/generic-tag-match.rs
@@ -14,7 +14,7 @@ enum foo<T> { arm(T), }
 
 fn altfoo<T>(f: foo<T>) {
     let mut hit = false;
-    match f { arm::<T>(_x) => { info!("in arm"); hit = true; } }
+    match f { arm::<T>(_x) => { println!("in arm"); hit = true; } }
     assert!((hit));
 }
 
diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs
index 7c4139664af..e9848960180 100644
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -17,12 +17,12 @@ struct Pair { x: int, y: int }
 
 pub fn main() {
     let nop: noption<int> = some::<int>(5);
-    match nop { some::<int>(n) => { info!("{:?}", n); assert!((n == 5)); } }
+    match nop { some::<int>(n) => { println!("{:?}", n); assert!((n == 5)); } }
     let nop2: noption<Pair> = some(Pair{x: 17, y: 42});
     match nop2 {
       some(t) => {
-        info!("{:?}", t.x);
-        info!("{:?}", t.y);
+        println!("{:?}", t.x);
+        println!("{:?}", t.y);
         assert_eq!(t.x, 17);
         assert_eq!(t.y, 42);
       }
diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs
index f2dbc5a0d31..99be8a5478c 100644
--- a/src/test/run-pass/generic-temporary.rs
+++ b/src/test/run-pass/generic-temporary.rs
@@ -12,7 +12,7 @@
 
 fn mk() -> int { return 1; }
 
-fn chk(a: int) { info!("{}", a); assert!((a == 1)); }
+fn chk(a: int) { println!("{}", a); assert!((a == 1)); }
 
 fn apply<T>(produce: fn() -> T,
             consume: fn(T)) {
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index 9626884be9d..2e9bd371e29 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -11,7 +11,7 @@
 fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
 
 pub fn main() {
-    info!("{:?}", get_third((1, 2, 3)));
+    println!("{:?}", get_third((1, 2, 3)));
     assert_eq!(get_third((1, 2, 3)), 3);
     assert_eq!(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 fe27eca7730..20d33a09f79 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -51,11 +51,11 @@ mod map_reduce {
                 return;
             }
             let (tx, rx) = channel();
-            error!("sending find_reducer");
+            println!("sending find_reducer");
             ctrl.send(find_reducer(key.as_bytes().to_owned(), tx));
-            error!("receiving");
+            println!("receiving");
             let c = rx.recv();
-            error!("{:?}", c);
+            println!("{:?}", c);
             im.insert(key, c);
         }
 
diff --git a/src/test/run-pass/if-bot.rs b/src/test/run-pass/if-bot.rs
index 6ac169fed9b..97429131a7c 100644
--- a/src/test/run-pass/if-bot.rs
+++ b/src/test/run-pass/if-bot.rs
@@ -12,5 +12,5 @@
 
 pub fn main() {
     let i: int = if false { fail!() } else { 5 };
-    info!("{:?}", i);
+    println!("{:?}", i);
 }
diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs
index 50a1b4345dc..22b5281ef38 100644
--- a/src/test/run-pass/if-check.rs
+++ b/src/test/run-pass/if-check.rs
@@ -16,7 +16,7 @@ fn even(x: uint) -> bool {
 
 fn foo(x: uint) {
     if even(x) {
-        info!("{}", x);
+        println!("{}", x);
     } else {
         fail!();
     }
diff --git a/src/test/run-pass/import-glob-0.rs b/src/test/run-pass/import-glob-0.rs
index 2d939024527..dc5c7d11769 100644
--- a/src/test/run-pass/import-glob-0.rs
+++ b/src/test/run-pass/import-glob-0.rs
@@ -16,10 +16,10 @@ use module_of_many_things::*;
 use dug::too::greedily::and::too::deep::*;
 
 mod module_of_many_things {
-    pub fn f1() { info!("f1"); }
-    pub fn f2() { info!("f2"); }
-    fn f3() { info!("f3"); }
-    pub fn f4() { info!("f4"); }
+    pub fn f1() { println!("f1"); }
+    pub fn f2() { println!("f2"); }
+    fn f3() { println!("f3"); }
+    pub fn f4() { println!("f4"); }
 }
 
 mod dug {
@@ -28,8 +28,8 @@ mod dug {
             pub mod and {
                 pub mod too {
                     pub mod deep {
-                        pub fn nameless_fear() { info!("Boo!"); }
-                        pub fn also_redstone() { info!("Whatever."); }
+                        pub fn nameless_fear() { println!("Boo!"); }
+                        pub fn also_redstone() { println!("Whatever."); }
                     }
                 }
             }
diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs
index 176a7ba0047..5765df4dafa 100644
--- a/src/test/run-pass/import.rs
+++ b/src/test/run-pass/import.rs
@@ -11,7 +11,7 @@
 // except according to those terms.
 
 mod foo {
-    pub fn x(y: int) { info!("{:?}", y); }
+    pub fn x(y: int) { println!("{:?}", y); }
 }
 
 mod bar {
diff --git a/src/test/run-pass/import2.rs b/src/test/run-pass/import2.rs
index 756fa7d4563..7a3c6a13877 100644
--- a/src/test/run-pass/import2.rs
+++ b/src/test/run-pass/import2.rs
@@ -14,7 +14,7 @@
 use zed::bar;
 
 mod zed {
-    pub fn bar() { info!("bar"); }
+    pub fn bar() { println!("bar"); }
 }
 
 pub fn main() { bar(); }
diff --git a/src/test/run-pass/import3.rs b/src/test/run-pass/import3.rs
index 26128399105..651f86e5898 100644
--- a/src/test/run-pass/import3.rs
+++ b/src/test/run-pass/import3.rs
@@ -17,7 +17,7 @@ use baz::zed::bar;
 
 mod baz {
     pub mod zed {
-        pub fn bar() { info!("bar2"); }
+        pub fn bar() { println!("bar2"); }
     }
 }
 
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 73b3f4e3483..ff858e81bb8 100644
--- a/src/test/run-pass/import4.rs
+++ b/src/test/run-pass/import4.rs
@@ -14,7 +14,7 @@
 use zed::bar;
 
 mod zed {
-    pub fn bar() { info!("bar"); }
+    pub fn bar() { println!("bar"); }
 }
 
 pub fn main() { let _zed = 42; bar(); }
diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs
index 157ae16c5e7..f41e4d7d373 100644
--- a/src/test/run-pass/import5.rs
+++ b/src/test/run-pass/import5.rs
@@ -14,7 +14,7 @@ use foo::bar;
 mod foo {
     pub use foo::zed::bar;
     pub mod zed {
-        pub fn bar() { info!("foo"); }
+        pub fn bar() { println!("foo"); }
     }
 }
 
diff --git a/src/test/run-pass/import6.rs b/src/test/run-pass/import6.rs
index ed5ac89145c..cf8dfd5469c 100644
--- a/src/test/run-pass/import6.rs
+++ b/src/test/run-pass/import6.rs
@@ -17,7 +17,7 @@ use bar::baz;
 
 mod foo {
     pub mod zed {
-        pub fn baz() { info!("baz"); }
+        pub fn baz() { println!("baz"); }
     }
 }
 mod bar {
diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs
index 63b6cd3b42f..fadbc534519 100644
--- a/src/test/run-pass/import7.rs
+++ b/src/test/run-pass/import7.rs
@@ -17,7 +17,7 @@ use bar::baz;
 
 mod foo {
     pub mod zed {
-        pub fn baz() { info!("baz"); }
+        pub fn baz() { println!("baz"); }
     }
 }
 mod bar {
diff --git a/src/test/run-pass/import8.rs b/src/test/run-pass/import8.rs
index e3d9a68afcc..69706a324b6 100644
--- a/src/test/run-pass/import8.rs
+++ b/src/test/run-pass/import8.rs
@@ -15,7 +15,7 @@ use foo::x;
 use z = foo::x;
 
 mod foo {
-    pub fn x(y: int) { info!("{}", y); }
+    pub fn x(y: int) { println!("{}", y); }
 }
 
 pub fn main() { x(10); z(10); }
diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs
index 6dbc80c6a45..95a10df5f81 100644
--- a/src/test/run-pass/inner-module.rs
+++ b/src/test/run-pass/inner-module.rs
@@ -13,7 +13,7 @@
 
 mod inner {
     pub mod inner2 {
-        pub fn hello() { info!("hello, modular world"); }
+        pub fn hello() { println!("hello, modular world"); }
     }
     pub fn hello() { inner2::hello(); }
 }
diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
index edc71b524e3..18ff6fe1896 100644
--- a/src/test/run-pass/integral-indexing.rs
+++ b/src/test/run-pass/integral-indexing.rs
@@ -20,11 +20,11 @@ pub fn main() {
     assert_eq!(v[3i8], 3);
     assert_eq!(v[3u32], 3);
     assert_eq!(v[3i32], 3);
-    info!("{}", v[3u8]);
+    println!("{}", v[3u8]);
     assert_eq!(s[3u], 'd' as u8);
     assert_eq!(s[3u8], 'd' as u8);
     assert_eq!(s[3i8], 'd' as u8);
     assert_eq!(s[3u32], 'd' as u8);
     assert_eq!(s[3i32], 'd' as u8);
-    info!("{}", s[3u8]);
+    println!("{}", s[3u8]);
 }
diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs
index 14115fa52da..3f2c3f4fbd7 100644
--- a/src/test/run-pass/issue-10626.rs
+++ b/src/test/run-pass/issue-10626.rs
@@ -20,7 +20,7 @@ pub fn main () {
     let args = os::args();
     if args.len() > 1 && args[1] == ~"child" {
         for _ in range(0, 1000) {
-            error!("hello?");
+            println!("hello?");
         }
         for _ in range(0, 1000) {
             println!("hello?");
diff --git a/src/test/run-pass/issue-1696.rs b/src/test/run-pass/issue-1696.rs
index 2dbed23677f..48a1fd3f783 100644
--- a/src/test/run-pass/issue-1696.rs
+++ b/src/test/run-pass/issue-1696.rs
@@ -17,5 +17,5 @@ use collections::HashMap;
 pub fn main() {
     let mut m = HashMap::new();
     m.insert("foo".as_bytes().to_owned(), "bar".as_bytes().to_owned());
-    error!("{:?}", m);
+    println!("{:?}", m);
 }
diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs
index 4a1bb2ea877..311ce2d64b2 100644
--- a/src/test/run-pass/issue-2216.rs
+++ b/src/test/run-pass/issue-2216.rs
@@ -27,6 +27,6 @@ pub fn main() {
         break;
     }
 
-    error!("{:?}", x);
+    println!("{:?}", x);
     assert_eq!(x, 42);
 }
diff --git a/src/test/run-pass/issue-2633.rs b/src/test/run-pass/issue-2633.rs
index bde18d77b9a..a9ebfbcbf33 100644
--- a/src/test/run-pass/issue-2633.rs
+++ b/src/test/run-pass/issue-2633.rs
@@ -13,7 +13,7 @@ struct cat {
 }
 
 fn meow() {
-    error!("meow")
+    println!("meow")
 }
 
 fn cat() -> cat {
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 7c2c1eab87b..2e294c30a3f 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -296,16 +296,16 @@ pub mod pingpong {
 
 fn client(chan: pingpong::client::ping) {
     let chan = pingpong::client::do_ping(chan);
-    error!("Sent ping");
+    println!("Sent ping");
     let (_chan, _data) = pingpong::client::do_pong(chan);
-    error!("Received pong");
+    println!("Received pong");
 }
 
 fn server(chan: pingpong::server::ping) {
     let (chan, _data) = pingpong::server::do_ping(chan);
-    error!("Received ping");
+    println!("Received ping");
     let _chan = pingpong::server::do_pong(chan);
-    error!("Sent pong");
+    println!("Sent pong");
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/issue-2804-2.rs b/src/test/run-pass/issue-2804-2.rs
index 5e6ea5f6d44..fccd9f3da0b 100644
--- a/src/test/run-pass/issue-2804-2.rs
+++ b/src/test/run-pass/issue-2804-2.rs
@@ -18,7 +18,7 @@ extern crate collections;
 use collections::HashMap;
 
 fn add_interfaces(managed_ip: ~str, device: HashMap<~str, int>)  {
-     error!("{}, {:?}", managed_ip, device.get(&~"interfaces"));
+     println!("{}, {:?}", managed_ip, device.get(&~"interfaces"));
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
index 8370e0f7f9c..ca48f3ffd50 100644
--- a/src/test/run-pass/issue-2804.rs
+++ b/src/test/run-pass/issue-2804.rs
@@ -29,7 +29,7 @@ fn lookup(table: ~json::Object, key: ~str, default: ~str) -> ~str
             (*s).clone()
         }
         option::Some(value) => {
-            error!("{} was expected to be a string but is a {:?}", key, value);
+            println!("{} was expected to be a string but is a {:?}", key, value);
             default
         }
         option::None => {
@@ -48,7 +48,7 @@ fn add_interface(_store: int, managed_ip: ~str, data: json::Json) -> (~str, obje
             (label, bool_value(false))
         }
         _ => {
-            error!("Expected dict for {} interfaces but found {:?}", managed_ip, data);
+            println!("Expected dict for {} interfaces but found {:?}", managed_ip, data);
             (~"gnos:missing-interface", bool_value(true))
         }
     }
@@ -67,7 +67,7 @@ fn add_interfaces(store: int, managed_ip: ~str, device: HashMap<~str, json::Json
         }
         _ =>
         {
-            error!("Expected list for {} interfaces but found {:?}", managed_ip,
+            println!("Expected list for {} interfaces but found {:?}", managed_ip,
                    device.get(&~"interfaces"));
             ~[]
         }
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 463ed02a716..0fa93f37840 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -54,7 +54,7 @@ fn square_from_char(c: char) -> square {
       '.'  => { earth }
       ' '  => { empty }
       _ => {
-        error!("invalid square: {:?}", c);
+        println!("invalid square: {:?}", c);
         fail!()
       }
     }
diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs
index 8cf9436ef51..aeef29acd0e 100644
--- a/src/test/run-pass/issue-2935.rs
+++ b/src/test/run-pass/issue-2935.rs
@@ -29,6 +29,6 @@ pub fn main() {
     //  x.f();
     // y.f();
     // (*z).f();
-    error!("ok so far...");
+    println!("ok so far...");
     z.f(); //segfault
 }
diff --git a/src/test/run-pass/issue-3109.rs b/src/test/run-pass/issue-3109.rs
index 15580a01f7a..dc22ebce804 100644
--- a/src/test/run-pass/issue-3109.rs
+++ b/src/test/run-pass/issue-3109.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    error!("{:?}", ("hi there!", "you"));
+    println!("{:?}", ("hi there!", "you"));
 }
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index d50a1b6a0be..424f4648d8e 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -23,7 +23,7 @@ fn foo(name: ~str, samples_chan: Sender<Msg>) {
         let mut samples_chan = samples_chan;
         let callback: SamplesFn = proc(buffer) {
             for i in range(0u, buffer.len()) {
-                error!("{}: {}", i, buffer[i])
+                println!("{}: {}", i, buffer[i])
             }
         };
         samples_chan.send(GetSamples(name.clone(), callback));
diff --git a/src/test/run-pass/issue-4120.rs b/src/test/run-pass/issue-4120.rs
index 0e51da7dae1..8722376ab59 100644
--- a/src/test/run-pass/issue-4120.rs
+++ b/src/test/run-pass/issue-4120.rs
@@ -17,5 +17,5 @@ pub fn main()
     unsafe {
         libc::exit(0);
     }
-    error!("ack");
+    println!("ack");
 }
diff --git a/src/test/run-pass/issue-6344-let.rs b/src/test/run-pass/issue-6344-let.rs
index 05404b16f16..99d943a2f6b 100644
--- a/src/test/run-pass/issue-6344-let.rs
+++ b/src/test/run-pass/issue-6344-let.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let a = A { x: 0 };
 
     let A { x: ref x } = a;
-    info!("{:?}", x)
+    println!("{:?}", x)
 }
diff --git a/src/test/run-pass/issue-6344-match.rs b/src/test/run-pass/issue-6344-match.rs
index ddac1823546..f51221c419e 100644
--- a/src/test/run-pass/issue-6344-match.rs
+++ b/src/test/run-pass/issue-6344-match.rs
@@ -18,7 +18,7 @@ pub fn main() {
 
     match a {
         A { x : ref x } => {
-            info!("{:?}", x)
+            println!("{:?}", x)
         }
     }
 }
diff --git a/src/test/run-pass/issue-7563.rs b/src/test/run-pass/issue-7563.rs
index 11d392f1fb1..538699512a3 100644
--- a/src/test/run-pass/issue-7563.rs
+++ b/src/test/run-pass/issue-7563.rs
@@ -29,7 +29,7 @@ pub fn main() {
     let sa = A { a: 100 };
     let sb = B { b: 200, pa: &sa };
 
-    debug!("sa is {:?}", sa);
-    debug!("sb is {:?}", sb);
-    debug!("sb.pa is {:?}", sb.get_pa());
+    println!("sa is {:?}", sa);
+    println!("sb is {:?}", sb);
+    println!("sb.pa is {:?}", sb.get_pa());
 }
diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs
index 9b3db58ea9b..b8d56f761b8 100644
--- a/src/test/run-pass/istr.rs
+++ b/src/test/run-pass/istr.rs
@@ -10,7 +10,7 @@
 
 fn test_stack_assign() {
     let s: ~str = ~"a";
-    info!("{}", s.clone());
+    println!("{}", s.clone());
     let t: ~str = ~"a";
     assert!(s == t);
     let u: ~str = ~"b";
@@ -27,7 +27,7 @@ fn test_heap_assign() {
     assert!((s != u));
 }
 
-fn test_heap_log() { let s = ~"a big ol' string"; info!("{}", s); }
+fn test_heap_log() { let s = ~"a big ol' string"; println!("{}", s); }
 
 fn test_stack_add() {
     assert_eq!(~"a" + "b", ~"ab");
@@ -49,7 +49,7 @@ fn test_append() {
 
     let mut s = ~"a";
     s.push_str("b");
-    info!("{}", s.clone());
+    println!("{}", s.clone());
     assert_eq!(s, ~"ab");
 
     let mut s = ~"c";
diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs
index c44b7389666..794c4f4016e 100644
--- a/src/test/run-pass/iter-range.rs
+++ b/src/test/run-pass/iter-range.rs
@@ -19,5 +19,5 @@ fn range_(a: int, b: int, it: |int|) {
 pub fn main() {
     let mut sum: int = 0;
     range_(0, 100, |x| sum += x );
-    info!("{}", sum);
+    println!("{}", sum);
 }
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index 59baf63d284..a664daeb7f8 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -15,7 +15,7 @@ struct Refs { refs: ~[int], n: int }
 
 pub fn main() {
     let mut e = Refs{refs: ~[], n: 0};
-    let _f: || = || error!("{}", e.n);
+    let _f: || = || println!("{}", e.n);
     let x: &[int] = e.refs;
     assert_eq!(x.len(), 0);
 }
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index c34e65b2b42..f0149c811f0 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -16,5 +16,5 @@ pub fn main() {
     fn invoke(f: ||) { f(); }
     let k = ~22;
     let _u = A {a: k.clone()};
-    invoke(|| error!("{:?}", k.clone()) )
+    invoke(|| println!("{:?}", k.clone()) )
 }
diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
index a3dc848344c..aa303aa3b81 100644
--- a/src/test/run-pass/lazy-and-or.rs
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -16,7 +16,7 @@ pub fn main() {
     let x = 1 == 2 || 3 == 3;
     assert!((x));
     let mut y: int = 10;
-    info!("{:?}", x || incr(&mut y));
+    println!("{:?}", x || incr(&mut y));
     assert_eq!(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 d58e7f2a287..60f7689ecfa 100644
--- a/src/test/run-pass/lazy-init.rs
+++ b/src/test/run-pass/lazy-init.rs
@@ -10,6 +10,6 @@
 
 
 
-fn foo(x: int) { info!("{}", x); }
+fn foo(x: int) { println!("{}", x); }
 
 pub fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 67bbd096720..2e788737e4d 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -11,8 +11,8 @@
 pub fn main() {
     let x = ~[1, 2, 3];
     let mut y = 0;
-    for i in x.iter() { info!("{:?}", *i); y += *i; }
-    info!("{:?}", y);
+    for i in x.iter() { println!("{:?}", *i); y += *i; }
+    println!("{:?}", y);
     assert_eq!(y, 6);
     let s = ~"hello there";
     let mut i: int = 0;
@@ -25,8 +25,8 @@ pub fn main() {
         // ...
 
         i += 1;
-        info!("{:?}", i);
-        info!("{:?}", c);
+        println!("{:?}", i);
+        println!("{:?}", c);
     }
     assert_eq!(i, 11);
 }
diff --git a/src/test/run-pass/liveness-loop-break.rs b/src/test/run-pass/liveness-loop-break.rs
index 3e11f74f04a..0dba1830cbd 100644
--- a/src/test/run-pass/liveness-loop-break.rs
+++ b/src/test/run-pass/liveness-loop-break.rs
@@ -14,7 +14,7 @@ fn test() {
         v = 3;
         break;
     }
-    info!("{}", v);
+    println!("{}", v);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/log-err-phi.rs b/src/test/run-pass/log-err-phi.rs
index 57aeac9fcf8..01eabad1596 100644
--- a/src/test/run-pass/log-err-phi.rs
+++ b/src/test/run-pass/log-err-phi.rs
@@ -10,4 +10,4 @@
 
 
 
-pub fn main() { if false { error!("{}", ~"foo" + "bar"); } }
+pub fn main() { if false { println!("{}", ~"foo" + "bar"); } }
diff --git a/src/test/run-pass/log-poly.rs b/src/test/run-pass/log-poly.rs
index c5221cd73d7..b4a67328481 100644
--- a/src/test/run-pass/log-poly.rs
+++ b/src/test/run-pass/log-poly.rs
@@ -13,8 +13,8 @@ enum Numbers {
 }
 
 pub fn main() {
-    info!("{}", 1);
-    info!("{}", 2.0);
-    warn!("{:?}", Three);
-    error!("{:?}", ~[4]);
+    println!("{}", 1);
+    println!("{}", 2.0);
+    println!("{:?}", Three);
+    println!("{:?}", ~[4]);
 }
diff --git a/src/test/run-pass/logging-enabled-debug.rs b/src/test/run-pass/logging-enabled-debug.rs
index c5ff2bc46cd..b3a77aa9675 100644
--- a/src/test/run-pass/logging-enabled-debug.rs
+++ b/src/test/run-pass/logging-enabled-debug.rs
@@ -12,10 +12,12 @@
 // compile-flags:--cfg ndebug
 // exec-env:RUST_LOG=logging-enabled-debug=debug
 
-use std::logging;
+#[feature(phase)];
+#[phase(syntax, link)]
+extern crate log;
 
 pub fn main() {
-    if log_enabled!(logging::DEBUG) {
+    if log_enabled!(log::DEBUG) {
         fail!("what?! debugging?");
     }
 }
diff --git a/src/test/run-pass/logging-enabled.rs b/src/test/run-pass/logging-enabled.rs
index ba85db6f38b..587e0b9d4c5 100644
--- a/src/test/run-pass/logging-enabled.rs
+++ b/src/test/run-pass/logging-enabled.rs
@@ -11,13 +11,15 @@
 // ignore-fast
 // exec-env:RUST_LOG=logging-enabled=info
 
-use std::logging;
+#[feature(phase)];
+#[phase(syntax, link)]
+extern crate log;
 
 pub fn main() {
-    if log_enabled!(logging::DEBUG) {
+    if log_enabled!(log::DEBUG) {
         fail!("what?! debugging?");
     }
-    if !log_enabled!(logging::INFO) {
+    if !log_enabled!(log::INFO) {
         fail!("what?! no info?");
     }
 }
diff --git a/src/test/run-pass/logging-only-prints-once.rs b/src/test/run-pass/logging-only-prints-once.rs
index 4913df823b4..d582b770602 100644
--- a/src/test/run-pass/logging-only-prints-once.rs
+++ b/src/test/run-pass/logging-only-prints-once.rs
@@ -29,7 +29,7 @@ pub fn main() {
     let (tx, rx) = channel();
     spawn(proc() {
         let mut f = Foo(Cell::new(0));
-        debug!("{}", f);
+        println!("{}", f);
         let Foo(ref mut f) = f;
         assert!(f.get() == 1);
         tx.send(());
diff --git a/src/test/run-pass/loop-break-cont.rs b/src/test/run-pass/loop-break-cont.rs
index d6f148f559d..b9b16d10b8c 100644
--- a/src/test/run-pass/loop-break-cont.rs
+++ b/src/test/run-pass/loop-break-cont.rs
@@ -11,7 +11,7 @@
 pub fn main() {
   let mut i = 0u;
   loop {
-    error!("a");
+    println!("a");
     i += 1u;
     if i == 10u {
       break;
@@ -23,7 +23,7 @@ pub fn main() {
     if i == 21u {
         break;
     }
-    error!("b");
+    println!("b");
     is_even = false;
     i += 1u;
     if i % 2u != 0u {
@@ -33,7 +33,7 @@ pub fn main() {
   }
   assert!(!is_even);
   loop {
-    error!("c");
+    println!("c");
     if i == 22u {
         break;
     }
diff --git a/src/test/run-pass/macro-with-braces-in-expr-position.rs b/src/test/run-pass/macro-with-braces-in-expr-position.rs
index 2a368568f8c..fe1ef4817c6 100644
--- a/src/test/run-pass/macro-with-braces-in-expr-position.rs
+++ b/src/test/run-pass/macro-with-braces-in-expr-position.rs
@@ -20,9 +20,9 @@ macro_rules! spawn {
 
 pub fn main() {
     spawn! {
-        info!("stmt");
+        println!("stmt");
     };
     let _ = spawn! {
-        info!("expr");
+        println!("expr");
     };
 }
diff --git a/src/test/run-pass/match-bot.rs b/src/test/run-pass/match-bot.rs
index 861d72ea228..7e55e227cc0 100644
--- a/src/test/run-pass/match-bot.rs
+++ b/src/test/run-pass/match-bot.rs
@@ -12,5 +12,5 @@
 pub fn main() {
     let i: int =
         match Some::<int>(3) { None::<int> => { fail!() } Some::<int>(_) => { 5 } };
-    info!("{}", i);
+    println!("{}", i);
 }
diff --git a/src/test/run-pass/match-join.rs b/src/test/run-pass/match-join.rs
index d6654db854f..47b2ddd5022 100644
--- a/src/test/run-pass/match-join.rs
+++ b/src/test/run-pass/match-join.rs
@@ -25,4 +25,4 @@ fn foo<T>(y: Option<T>) {
     return;
 }
 
-pub fn main() { info!("hello"); foo::<int>(Some::<int>(5)); }
+pub fn main() { println!("hello"); foo::<int>(Some::<int>(5)); }
diff --git a/src/test/run-pass/match-pattern-drop.rs b/src/test/run-pass/match-pattern-drop.rs
index e0735e7ad24..e00ee118295 100644
--- a/src/test/run-pass/match-pattern-drop.rs
+++ b/src/test/run-pass/match-pattern-drop.rs
@@ -13,20 +13,20 @@
 enum t { make_t(@int), clam, }
 
 fn foo(s: @int) {
-    info!("{:?}", ::std::managed::refcount(s));
+    println!("{:?}", ::std::managed::refcount(s));
     let count = ::std::managed::refcount(s);
     let x: t = make_t(s); // ref up
     assert_eq!(::std::managed::refcount(s), count + 1u);
-    info!("{:?}", ::std::managed::refcount(s));
+    println!("{:?}", ::std::managed::refcount(s));
 
     match x {
       make_t(y) => {
-        info!("{:?}", y); // ref up then down
+        println!("{:?}", y); // ref up then down
 
       }
-      _ => { info!("?"); fail!(); }
+      _ => { println!("?"); fail!(); }
     }
-    info!("{:?}", ::std::managed::refcount(s));
+    println!("{:?}", ::std::managed::refcount(s));
     assert_eq!(::std::managed::refcount(s), count + 1u);
     let _ = ::std::managed::refcount(s); // don't get bitten by last-use.
 }
@@ -38,7 +38,7 @@ pub fn main() {
 
     foo(s); // ref up then down
 
-    info!("{}", ::std::managed::refcount(s));
+    println!("{}", ::std::managed::refcount(s));
     let count2 = ::std::managed::refcount(s);
     assert_eq!(count, count2);
 }
diff --git a/src/test/run-pass/match-pattern-lit.rs b/src/test/run-pass/match-pattern-lit.rs
index 84e9012be4e..9d59b197d3a 100644
--- a/src/test/run-pass/match-pattern-lit.rs
+++ b/src/test/run-pass/match-pattern-lit.rs
@@ -12,8 +12,8 @@
 
 fn altlit(f: int) -> int {
     match f {
-      10 => { info!("case 10"); return 20; }
-      11 => { info!("case 11"); return 22; }
+      10 => { println!("case 10"); return 20; }
+      11 => { println!("case 11"); return 22; }
       _  => fail!("the impossible happened")
     }
 }
diff --git a/src/test/run-pass/match-pattern-no-type-params.rs b/src/test/run-pass/match-pattern-no-type-params.rs
index 2076f46e8ab..e5be0e52b94 100644
--- a/src/test/run-pass/match-pattern-no-type-params.rs
+++ b/src/test/run-pass/match-pattern-no-type-params.rs
@@ -12,8 +12,8 @@ enum maybe<T> { nothing, just(T), }
 
 fn foo(x: maybe<int>) {
     match x {
-        nothing => { error!("A"); }
-        just(_a) => { error!("B"); }
+        nothing => { println!("A"); }
+        just(_a) => { println!("B"); }
     }
 }
 
diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs
index 50aa840e6d7..9fc3a7acf71 100644
--- a/src/test/run-pass/match-unique-bind.rs
+++ b/src/test/run-pass/match-unique-bind.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     match ~100 {
       ~x => {
-        info!("{:?}", x);
+        println!("{:?}", x);
         assert_eq!(x, 100);
       }
     }
diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs
index 4257442ea33..2109f7ef1ea 100644
--- a/src/test/run-pass/match-with-ret-arm.rs
+++ b/src/test/run-pass/match-with-ret-arm.rs
@@ -19,5 +19,5 @@ pub fn main() {
         Some(num) => num as u32
     };
     assert_eq!(f, 1234u32);
-    error!("{}", f)
+    println!("{}", f)
 }
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 34ce5c66539..e01128554c7 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -18,6 +18,6 @@ pub fn main() {
     grow(&mut v);
     grow(&mut v);
     let len = v.len();
-    info!("{}", len);
+    println!("{}", len);
     assert_eq!(len, 3 as uint);
 }
diff --git a/src/test/run-pass/nested-matchs.rs b/src/test/run-pass/nested-matchs.rs
index a516e2bf9bc..5f86cde261c 100644
--- a/src/test/run-pass/nested-matchs.rs
+++ b/src/test/run-pass/nested-matchs.rs
@@ -16,9 +16,9 @@ fn foo() {
       Some::<int>(_x) => {
         let mut bar;
         match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } }
-        info!("{:?}", bar);
+        println!("{:?}", bar);
       }
-      None::<int> => { info!("hello"); }
+      None::<int> => { println!("hello"); }
     }
 }
 
diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs
index 0bc6280393c..bc03b0d27ca 100644
--- a/src/test/run-pass/nested-pattern.rs
+++ b/src/test/run-pass/nested-pattern.rs
@@ -16,8 +16,8 @@ enum t { foo(int, uint), bar(int, Option<int>), }
 
 fn nested(o: t) {
     match o {
-        bar(_i, Some::<int>(_)) => { error!("wrong pattern matched"); fail!(); }
-        _ => { error!("succeeded"); }
+        bar(_i, Some::<int>(_)) => { println!("wrong pattern matched"); fail!(); }
+        _ => { println!("succeeded"); }
     }
 }
 
diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs
index 1fda2c80608..3f00cf7d184 100644
--- a/src/test/run-pass/opeq.rs
+++ b/src/test/run-pass/opeq.rs
@@ -14,15 +14,15 @@
 pub fn main() {
     let mut x: int = 1;
     x *= 2;
-    info!("{}", x);
+    println!("{}", x);
     assert_eq!(x, 2);
     x += 3;
-    info!("{}", x);
+    println!("{}", x);
     assert_eq!(x, 5);
     x *= x;
-    info!("{}", x);
+    println!("{}", x);
     assert_eq!(x, 25);
     x /= 5;
-    info!("{}", x);
+    println!("{}", x);
     assert_eq!(x, 5);
 }
diff --git a/src/test/run-pass/over-constrained-vregs.rs b/src/test/run-pass/over-constrained-vregs.rs
index cbd0416cb69..9a2e83ef2d0 100644
--- a/src/test/run-pass/over-constrained-vregs.rs
+++ b/src/test/run-pass/over-constrained-vregs.rs
@@ -17,6 +17,6 @@ pub fn main() {
     while b <= 32u {
         0u << b;
         b <<= 1u;
-        info!("{:?}", b);
+        println!("{:?}", b);
     }
 }
diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs
index 751ba78b282..d9669812d2a 100644
--- a/src/test/run-pass/paren-free.rs
+++ b/src/test/run-pass/paren-free.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let x = true;
     if x { let mut i = 10; while i > 0 { i -= 1; } }
-    match x { true => { info!("right"); } false => { info!("wrong"); } }
+    match x { true => { println!("right"); } false => { println!("wrong"); } }
 }
diff --git a/src/test/run-pass/parse-fail.rs b/src/test/run-pass/parse-fail.rs
index 087c04e0ff0..45f19a30e86 100644
--- a/src/test/run-pass/parse-fail.rs
+++ b/src/test/run-pass/parse-fail.rs
@@ -10,6 +10,6 @@
 
 #[allow(unreachable_code)];
 
-fn dont_call_me() { fail!(); info!("{}", 1); }
+fn dont_call_me() { fail!(); println!("{}", 1); }
 
 pub fn main() { }
diff --git a/src/test/run-pass/pass-by-copy.rs b/src/test/run-pass/pass-by-copy.rs
index 0f7e33ce340..fed766b23d9 100644
--- a/src/test/run-pass/pass-by-copy.rs
+++ b/src/test/run-pass/pass-by-copy.rs
@@ -10,8 +10,8 @@
 
 #[feature(managed_boxes)];
 
-fn magic(x: A) { info!("{:?}", x); }
-fn magic2(x: @int) { info!("{:?}", x); }
+fn magic(x: A) { println!("{:?}", x); }
+fn magic2(x: @int) { println!("{:?}", x); }
 
 struct A { a: @int }
 
diff --git a/src/test/run-pass/preempt.rs b/src/test/run-pass/preempt.rs
index df1d22f2c86..53d2a47863b 100644
--- a/src/test/run-pass/preempt.rs
+++ b/src/test/run-pass/preempt.rs
@@ -15,9 +15,9 @@
 use std::comm;
 
 fn starve_main(alive: Receiver<int>) {
-    info!("signalling main");
+    println!("signalling main");
     alive.recv();
-    info!("starving main");
+    println!("starving main");
     let mut i: int = 0;
     loop { i += 1; }
 }
@@ -25,14 +25,14 @@ fn starve_main(alive: Receiver<int>) {
 pub fn main() {
     let (port, chan) = stream();
 
-    info!("main started");
+    println!("main started");
     spawn(proc() {
         starve_main(port);
     });
     let mut i: int = 0;
-    info!("main waiting for alive signal");
+    println!("main waiting for alive signal");
     chan.send(i);
-    info!("main got alive signal");
-    while i < 50 { info!("main iterated"); i += 1; }
-    info!("main completed");
+    println!("main got alive signal");
+    while i < 50 { println!("main iterated"); i += 1; }
+    println!("main completed");
 }
diff --git a/src/test/run-pass/purity-infer.rs b/src/test/run-pass/purity-infer.rs
index bbb312842ce..3bceefb8318 100644
--- a/src/test/run-pass/purity-infer.rs
+++ b/src/test/run-pass/purity-infer.rs
@@ -11,5 +11,5 @@
 
 fn something(f: ||) { f(); }
 pub fn main() {
-    something(|| error!("hi!") );
+    something(|| println!("hi!") );
 }
diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs
index 8c1be0a6219..26e6f568ce2 100644
--- a/src/test/run-pass/rcvr-borrowed-to-region.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-region.rs
@@ -30,16 +30,16 @@ pub fn main() {
 
     let x = @6;
     let y = x.get();
-    info!("y={}", y);
+    println!("y={}", y);
     assert_eq!(y, 6);
 
     let x = ~6;
     let y = x.get();
-    info!("y={}", y);
+    println!("y={}", y);
     assert_eq!(y, 6);
 
     let x = &6;
     let y = x.get();
-    info!("y={}", y);
+    println!("y={}", y);
     assert_eq!(y, 6);
 }
diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs
index 050a51c958d..b958588622f 100644
--- a/src/test/run-pass/rcvr-borrowed-to-slice.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs
@@ -24,16 +24,16 @@ fn call_sum(x: &[int]) -> int { x.sum_() }
 pub fn main() {
     let x = ~[1, 2, 3];
     let y = call_sum(x);
-    info!("y=={}", y);
+    println!("y=={}", y);
     assert_eq!(y, 6);
 
     let x = ~[1, 2, 3];
     let y = x.sum_();
-    info!("y=={}", y);
+    println!("y=={}", y);
     assert_eq!(y, 6);
 
     let x = ~[1, 2, 3];
     let y = x.sum_();
-    info!("y=={}", y);
+    println!("y=={}", y);
     assert_eq!(y, 6);
 }
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index 86745deaad8..49e0faf4693 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -54,9 +54,9 @@ pub fn main() {
         // Send it through the shape code
         let y = format!("{:?}", x);
 
-        info!("align inner = {:?}", rusti::min_align_of::<Inner>());
-        info!("size outer = {:?}", mem::size_of::<Outer>());
-        info!("y = {}", y);
+        println!("align inner = {:?}", rusti::min_align_of::<Inner>());
+        println!("size outer = {:?}", mem::size_of::<Outer>());
+        println!("y = {}", y);
 
         // per clang/gcc the alignment of `inner` is 4 on x86.
         assert_eq!(rusti::min_align_of::<Inner>(), m::align());
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index 560425dcb21..16d1a0c464c 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -76,9 +76,9 @@ pub fn main() {
         // Send it through the shape code
         let y = format!("{:?}", x);
 
-        info!("align inner = {}", rusti::min_align_of::<Inner>());
-        info!("size outer = {}", mem::size_of::<Outer>());
-        info!("y = {}", y);
+        println!("align inner = {}", rusti::min_align_of::<Inner>());
+        println!("size outer = {}", mem::size_of::<Outer>());
+        println!("y = {}", y);
 
         // per clang/gcc the alignment of `Inner` is 4 on x86.
         assert_eq!(rusti::min_align_of::<Inner>(), m::m::align());
diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs
index 57da2e03832..a1d57241e07 100644
--- a/src/test/run-pass/rec-auto.rs
+++ b/src/test/run-pass/rec-auto.rs
@@ -18,6 +18,6 @@ struct X { foo: ~str, bar: ~str }
 
 pub fn main() {
     let x = X {foo: ~"hello", bar: ~"world"};
-    info!("{}", x.foo.clone());
-    info!("{}", x.bar.clone());
+    println!("{}", x.foo.clone());
+    println!("{}", x.bar.clone());
 }
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index f81ddabf77c..6f91497a81c 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -19,32 +19,32 @@ struct MyVisitor {
 impl TyVisitor for MyVisitor {
     fn visit_bot(&mut self) -> bool {
         self.types.push(~"bot");
-        error!("visited bot type");
+        println!("visited bot type");
         true
     }
     fn visit_nil(&mut self) -> bool {
         self.types.push(~"nil");
-        error!("visited nil type");
+        println!("visited nil type");
         true
     }
     fn visit_bool(&mut self) -> bool {
         self.types.push(~"bool");
-        error!("visited bool type");
+        println!("visited bool type");
         true
     }
     fn visit_int(&mut self) -> bool {
         self.types.push(~"int");
-        error!("visited int type");
+        println!("visited int type");
         true
     }
     fn visit_i8(&mut self) -> bool {
         self.types.push(~"i8");
-        error!("visited i8 type");
+        println!("visited i8 type");
         true
     }
     fn visit_i16(&mut self) -> bool {
         self.types.push(~"i16");
-        error!("visited i16 type");
+        println!("visited i16 type");
         true
     }
     fn visit_i32(&mut self) -> bool { true }
diff --git a/src/test/run-pass/regions-addr-of-ret.rs b/src/test/run-pass/regions-addr-of-ret.rs
index 898759f67d2..357d829627d 100644
--- a/src/test/run-pass/regions-addr-of-ret.rs
+++ b/src/test/run-pass/regions-addr-of-ret.rs
@@ -14,5 +14,5 @@ fn f<'a>(x : &'a int) -> &'a int {
 
 pub fn main() {
     let three = &3;
-    error!("{}", *f(three));
+    println!("{}", *f(three));
 }
diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs
index 5b1b1dd8ec3..994140ee144 100644
--- a/src/test/run-pass/regions-borrow-at.rs
+++ b/src/test/run-pass/regions-borrow-at.rs
@@ -17,6 +17,6 @@ fn foo(x: &uint) -> uint {
 pub fn main() {
     let p = @22u;
     let r = foo(p);
-    info!("r={}", r);
+    println!("r={}", r);
     assert_eq!(r, 22u);
 }
diff --git a/src/test/run-pass/regions-self-impls.rs b/src/test/run-pass/regions-self-impls.rs
index cc8174d0d32..f1e6c6a0e2f 100644
--- a/src/test/run-pass/regions-self-impls.rs
+++ b/src/test/run-pass/regions-self-impls.rs
@@ -22,6 +22,6 @@ impl<'a> get_chowder<'a> for Clam<'a> {
 
 pub fn main() {
     let clam = Clam { chowder: &3 };
-    info!("{:?}", *clam.get_chowder());
+    println!("{:?}", *clam.get_chowder());
     clam.get_chowder();
 }
diff --git a/src/test/run-pass/regions-self-in-enums.rs b/src/test/run-pass/regions-self-in-enums.rs
index 6e2d62cce92..c4037a70d96 100644
--- a/src/test/run-pass/regions-self-in-enums.rs
+++ b/src/test/run-pass/regions-self-in-enums.rs
@@ -19,5 +19,5 @@ pub fn main() {
     match y {
         int_wrapper_ctor(zz) => { z = zz; }
     }
-    info!("{:?}", *z);
+    println!("{:?}", *z);
 }
diff --git a/src/test/run-pass/regions-simple.rs b/src/test/run-pass/regions-simple.rs
index bb612c5b0df..62be5860508 100644
--- a/src/test/run-pass/regions-simple.rs
+++ b/src/test/run-pass/regions-simple.rs
@@ -12,5 +12,5 @@ pub fn main() {
     let mut x: int = 3;
     let y: &mut int = &mut x;
     *y = 5;
-    info!("{:?}", *y);
+    println!("{:?}", *y);
 }
diff --git a/src/test/run-pass/regions-static-closure.rs b/src/test/run-pass/regions-static-closure.rs
index 9d994c423c9..ff4b43cb6b5 100644
--- a/src/test/run-pass/regions-static-closure.rs
+++ b/src/test/run-pass/regions-static-closure.rs
@@ -21,6 +21,6 @@ fn call_static_closure(cl: closure_box<'static>) {
 }
 
 pub fn main() {
-    let cl_box = box_it(|| info!("Hello, world!"));
+    let cl_box = box_it(|| println!("Hello, world!"));
     call_static_closure(cl_box);
 }
diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index 9f206990843..e091092b653 100644
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -19,6 +19,6 @@ pub fn main() {
     let x = [ [true], ..512 ];
     let y = [ 0, ..1 ];
 
-    error!("{:?}", x);
-    error!("{:?}", y);
+    println!("{:?}", x);
+    println!("{:?}", 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 bec101a6d45..55d9a8bc63a 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -36,7 +36,7 @@ pub fn main() {
         let a = r(i);
         let b = (a, 10);
         let (c, _d) = b;
-        info!("{:?}", c);
+        println!("{:?}", c);
     }
     assert_eq!(i.get(), 1);
 }
diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs
index 93183f8dba4..af0e9572f38 100644
--- a/src/test/run-pass/resource-destruct.rs
+++ b/src/test/run-pass/resource-destruct.rs
@@ -19,7 +19,7 @@ struct shrinky_pointer {
 #[unsafe_destructor]
 impl Drop for shrinky_pointer {
     fn drop(&mut self) {
-        error!("Hello!"); self.i.set(self.i.get() - 1);
+        println!("Hello!"); self.i.set(self.i.get() - 1);
     }
 }
 
@@ -36,6 +36,6 @@ fn shrinky_pointer(i: @@Cell<int>) -> shrinky_pointer {
 pub fn main() {
     let my_total = @@Cell::new(10);
     { let pt = shrinky_pointer(my_total); assert!((pt.look_at() == 10)); }
-    error!("my_total = {}", my_total.get());
+    println!("my_total = {}", my_total.get());
     assert_eq!(my_total.get(), 9);
 }
diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs
index 4f9e3c2c1f6..468b6ca51a0 100644
--- a/src/test/run-pass/ret-bang.rs
+++ b/src/test/run-pass/ret-bang.rs
@@ -11,7 +11,7 @@
 
 
 
-fn my_err(s: ~str) -> ! { error!("{:?}", s); fail!(); }
+fn my_err(s: ~str) -> ! { println!("{:?}", s); fail!(); }
 
 fn okay(i: uint) -> int {
     if i == 3u { my_err(~"I don't like three"); } else { return 42; }
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 a39907d5c7e..835b5990ac2 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -19,7 +19,7 @@ fn test05_start(f: proc(int)) {
 fn test05() {
     let three = ~3;
     let fn_to_send: proc(int) = proc(n) {
-        error!("{}", *three + n); // will copy x into the closure
+        println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
     task::spawn(proc() {
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index c5211889f3f..b277c16dc4a 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -16,7 +16,7 @@ fn foo(c: ~[int]) {
     match none::<int> {
         some::<int>(_) => {
             for _i in c.iter() {
-                info!("{:?}", a);
+                println!("{:?}", a);
                 let a = 17;
                 b.push(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 cb8d7310874..b74f080ede7 100644
--- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
+++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
@@ -59,6 +59,6 @@ pub fn main() {
     let p_: Path_ = Path_ { global: true, idents: ~[~"hi"], types: ~[t] };
     let p: path = Spanned { data: p_, span: sp };
     let x = X { sp: sp, path: p };
-    error!("{:?}", x.path.clone());
-    error!("{:?}", x.clone());
+    println!("{:?}", x.path.clone());
+    println!("{:?}", x.clone());
 }
diff --git a/src/test/run-pass/simple-infer.rs b/src/test/run-pass/simple-infer.rs
index e3d3b3389ba..04c1af4326b 100644
--- a/src/test/run-pass/simple-infer.rs
+++ b/src/test/run-pass/simple-infer.rs
@@ -10,4 +10,4 @@
 
 
 
-pub fn main() { let mut n; n = 1; info!("{}", n); }
+pub fn main() { let mut n; n = 1; println!("{}", n); }
diff --git a/src/test/run-pass/simple-match-generic-tag.rs b/src/test/run-pass/simple-match-generic-tag.rs
index d8b7c99d000..c0c1135b6d5 100644
--- a/src/test/run-pass/simple-match-generic-tag.rs
+++ b/src/test/run-pass/simple-match-generic-tag.rs
@@ -14,5 +14,5 @@ enum opt<T> { none, }
 
 pub fn main() {
     let x = none::<int>;
-    match x { none::<int> => { info!("hello world"); } }
+    match x { none::<int> => { println!("hello world"); } }
 }
diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index 2caef2d1b9e..5731b8de529 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -16,11 +16,11 @@ enum clam<T> { a(T, int), b, }
 fn uhoh<T>(v: ~[clam<T>]) {
     match v[1] {
       a::<T>(ref _t, ref u) => {
-          info!("incorrect");
-          info!("{:?}", u);
+          println!("incorrect");
+          println!("{:?}", u);
           fail!();
       }
-      b::<T> => { info!("correct"); }
+      b::<T> => { println!("correct"); }
     }
 }
 
diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs
index 8c9de64687e..fe4e38ee879 100644
--- a/src/test/run-pass/spawn-fn.rs
+++ b/src/test/run-pass/spawn-fn.rs
@@ -11,8 +11,8 @@
 use std::task;
 
 fn x(s: ~str, n: int) {
-    info!("{:?}", s);
-    info!("{:?}", n);
+    println!("{:?}", s);
+    println!("{:?}", n);
 }
 
 pub fn main() {
@@ -20,5 +20,5 @@ pub fn main() {
     task::spawn(proc() x(~"hello from second spawned fn", 66) );
     task::spawn(proc() x(~"hello from third spawned fn", 67) );
     let mut i: int = 30;
-    while i > 0 { i = i - 1; info!("parent sleeping"); task::deschedule(); }
+    while i > 0 { i = i - 1; println!("parent sleeping"); task::deschedule(); }
 }
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index 987aa9ee7e3..741e20d42db 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -14,4 +14,4 @@ pub fn main() {
     task::spawn(proc() child(10) );
 }
 
-fn child(i: int) { error!("{}", i); assert!((i == 10)); }
+fn child(i: int) { println!("{}", i); assert!((i == 10)); }
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 8530c583b16..6bac7f2a06e 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -14,15 +14,15 @@ pub fn main() { task::spawn(proc() child((10, 20, 30, 40, 50, 60, 70, 80, 90)) )
 
 fn child(args: (int, int, int, int, int, int, int, int, int)) {
     let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
-    error!("{}", i1);
-    error!("{}", i2);
-    error!("{}", i3);
-    error!("{}", i4);
-    error!("{}", i5);
-    error!("{}", i6);
-    error!("{}", i7);
-    error!("{}", i8);
-    error!("{}", i9);
+    println!("{}", i1);
+    println!("{}", i2);
+    println!("{}", i3);
+    println!("{}", i4);
+    println!("{}", i5);
+    println!("{}", i6);
+    println!("{}", i7);
+    println!("{}", i8);
+    println!("{}", i9);
     assert_eq!(i1, 10);
     assert_eq!(i2, 20);
     assert_eq!(i3, 30);
diff --git a/src/test/run-pass/spawning-with-debug.rs b/src/test/run-pass/spawning-with-debug.rs
index 714dddf4ab6..db8dc0f64c4 100644
--- a/src/test/run-pass/spawning-with-debug.rs
+++ b/src/test/run-pass/spawning-with-debug.rs
@@ -11,7 +11,7 @@
 // exec-env:RUST_LOG=debug
 // ignore-fast
 
-// regression test for issue #10405, make sure we don't call debug! too soon.
+// regression test for issue #10405, make sure we don't call println! too soon.
 
 use std::task;
 
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index 90d5bae56f4..ad6e668524c 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -11,7 +11,7 @@
 fn test1() {
     let mut s: ~str = ~"hello";
     s.push_str("world");
-    info!("{}", s.clone());
+    println!("{}", s.clone());
     assert_eq!(s[9], 'd' as u8);
 }
 
@@ -21,8 +21,8 @@ fn test2() {
     let ff: ~str = ~"abc";
     let a: ~str = ff + "ABC" + ff;
     let b: ~str = ~"ABC" + ff + "ABC";
-    info!("{}", a.clone());
-    info!("{}", b.clone());
+    println!("{}", a.clone());
+    println!("{}", b.clone());
     assert_eq!(a, ~"abcABCabc");
     assert_eq!(b, ~"ABCabcABC");
 }
diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
index 8b87682384b..627bb54dad3 100644
--- a/src/test/run-pass/str-concat.rs
+++ b/src/test/run-pass/str-concat.rs
@@ -15,6 +15,6 @@ pub fn main() {
     let a: ~str = ~"hello";
     let b: ~str = ~"world";
     let s: ~str = a + b;
-    info!("{}", s.clone());
+    println!("{}", s.clone());
     assert_eq!(s[9], 'd' as u8);
 }
diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs
index ebed8e24a48..37abb4be87f 100644
--- a/src/test/run-pass/str-idx.rs
+++ b/src/test/run-pass/str-idx.rs
@@ -13,6 +13,6 @@
 pub fn main() {
     let s = ~"hello";
     let c: u8 = s[4];
-    info!("{:?}", c);
+    println!("{:?}", c);
     assert_eq!(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 10230065b91..f2fa8a06bfd 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -14,7 +14,7 @@ pub fn main() {
     let mut i = 20;
     let mut expected_len = 1u;
     while i > 0 {
-        error!("{}", a.len());
+        println!("{}", a.len());
         assert_eq!(a.len(), expected_len);
         a = a + a; // FIXME(#3387)---can't write a += a
         i -= 1;
diff --git a/src/test/run-pass/struct-literal-dtor.rs b/src/test/run-pass/struct-literal-dtor.rs
index c5f8d0410d8..0657f1a8fae 100644
--- a/src/test/run-pass/struct-literal-dtor.rs
+++ b/src/test/run-pass/struct-literal-dtor.rs
@@ -14,7 +14,7 @@ struct foo {
 
 impl Drop for foo {
     fn drop(&mut self) {
-        error!("{}", self.x);
+        println!("{}", self.x);
     }
 }
 
diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs
index c668981b40a..f9a5de40f49 100644
--- a/src/test/run-pass/struct-return.rs
+++ b/src/test/run-pass/struct-return.rs
@@ -30,10 +30,10 @@ fn test1() {
                  c: 0xcccc_cccc_cccc_cccc_u64,
                  d: 0xdddd_dddd_dddd_dddd_u64 };
         let qq = rustrt::rust_dbg_abi_1(q);
-        error!("a: {:x}", qq.a as uint);
-        error!("b: {:x}", qq.b as uint);
-        error!("c: {:x}", qq.c as uint);
-        error!("d: {:x}", qq.d as uint);
+        println!("a: {:x}", qq.a as uint);
+        println!("b: {:x}", qq.b as uint);
+        println!("c: {:x}", qq.c as uint);
+        println!("d: {:x}", qq.d as uint);
         assert_eq!(qq.a, q.c + 1u64);
         assert_eq!(qq.b, q.d - 1u64);
         assert_eq!(qq.c, q.a + 1u64);
@@ -48,9 +48,9 @@ fn test2() {
                  b: 0b_1010_1010_u8,
                  c: 1.0987654321e-15_f64 };
         let ff = rustrt::rust_dbg_abi_2(f);
-        error!("a: {}", ff.a as f64);
-        error!("b: {}", ff.b as uint);
-        error!("c: {}", ff.c as f64);
+        println!("a: {}", ff.a as f64);
+        println!("b: {}", ff.b as uint);
+        println!("c: {}", ff.c as f64);
         assert_eq!(ff.a, f.c + 1.0f64);
         assert_eq!(ff.b, 0xff_u8);
         assert_eq!(ff.c, f.a - 1.0f64);
diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs
index 60e5a157bfc..e3f2456c4c4 100644
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -12,221 +12,221 @@ use std::libc;
 
 pub fn main() {
   let f = 1 as *libc::FILE;
-  info!("{}", f as int);
-  info!("{}", f as uint);
-  info!("{}", f as i8);
-  info!("{}", f as i16);
-  info!("{}", f as i32);
-  info!("{}", f as i64);
-  info!("{}", f as u8);
-  info!("{}", f as u16);
-  info!("{}", f as u32);
-  info!("{}", f as u64);
+  println!("{}", f as int);
+  println!("{}", f as uint);
+  println!("{}", f as i8);
+  println!("{}", f as i16);
+  println!("{}", f as i32);
+  println!("{}", f as i64);
+  println!("{}", f as u8);
+  println!("{}", f as u16);
+  println!("{}", f as u32);
+  println!("{}", f as u64);
 
-  info!("{}", 1 as int);
-  info!("{}", 1 as uint);
-  info!("{}", 1 as *libc::FILE);
-  info!("{}", 1 as i8);
-  info!("{}", 1 as i16);
-  info!("{}", 1 as i32);
-  info!("{}", 1 as i64);
-  info!("{}", 1 as u8);
-  info!("{}", 1 as u16);
-  info!("{}", 1 as u32);
-  info!("{}", 1 as u64);
-  info!("{}", 1 as f32);
-  info!("{}", 1 as f64);
+  println!("{}", 1 as int);
+  println!("{}", 1 as uint);
+  println!("{}", 1 as *libc::FILE);
+  println!("{}", 1 as i8);
+  println!("{}", 1 as i16);
+  println!("{}", 1 as i32);
+  println!("{}", 1 as i64);
+  println!("{}", 1 as u8);
+  println!("{}", 1 as u16);
+  println!("{}", 1 as u32);
+  println!("{}", 1 as u64);
+  println!("{}", 1 as f32);
+  println!("{}", 1 as f64);
 
-  info!("{}", 1u as int);
-  info!("{}", 1u as uint);
-  info!("{}", 1u as *libc::FILE);
-  info!("{}", 1u as i8);
-  info!("{}", 1u as i16);
-  info!("{}", 1u as i32);
-  info!("{}", 1u as i64);
-  info!("{}", 1u as u8);
-  info!("{}", 1u as u16);
-  info!("{}", 1u as u32);
-  info!("{}", 1u as u64);
-  info!("{}", 1u as f32);
-  info!("{}", 1u as f64);
+  println!("{}", 1u as int);
+  println!("{}", 1u as uint);
+  println!("{}", 1u as *libc::FILE);
+  println!("{}", 1u as i8);
+  println!("{}", 1u as i16);
+  println!("{}", 1u as i32);
+  println!("{}", 1u as i64);
+  println!("{}", 1u as u8);
+  println!("{}", 1u as u16);
+  println!("{}", 1u as u32);
+  println!("{}", 1u as u64);
+  println!("{}", 1u as f32);
+  println!("{}", 1u as f64);
 
-  info!("{}", 1i8 as int);
-  info!("{}", 1i8 as uint);
-  info!("{}", 1i8 as *libc::FILE);
-  info!("{}", 1i8 as i8);
-  info!("{}", 1i8 as i16);
-  info!("{}", 1i8 as i32);
-  info!("{}", 1i8 as i64);
-  info!("{}", 1i8 as u8);
-  info!("{}", 1i8 as u16);
-  info!("{}", 1i8 as u32);
-  info!("{}", 1i8 as u64);
-  info!("{}", 1i8 as f32);
-  info!("{}", 1i8 as f64);
+  println!("{}", 1i8 as int);
+  println!("{}", 1i8 as uint);
+  println!("{}", 1i8 as *libc::FILE);
+  println!("{}", 1i8 as i8);
+  println!("{}", 1i8 as i16);
+  println!("{}", 1i8 as i32);
+  println!("{}", 1i8 as i64);
+  println!("{}", 1i8 as u8);
+  println!("{}", 1i8 as u16);
+  println!("{}", 1i8 as u32);
+  println!("{}", 1i8 as u64);
+  println!("{}", 1i8 as f32);
+  println!("{}", 1i8 as f64);
 
-  info!("{}", 1u8 as int);
-  info!("{}", 1u8 as uint);
-  info!("{}", 1u8 as *libc::FILE);
-  info!("{}", 1u8 as i8);
-  info!("{}", 1u8 as i16);
-  info!("{}", 1u8 as i32);
-  info!("{}", 1u8 as i64);
-  info!("{}", 1u8 as u8);
-  info!("{}", 1u8 as u16);
-  info!("{}", 1u8 as u32);
-  info!("{}", 1u8 as u64);
-  info!("{}", 1u8 as f32);
-  info!("{}", 1u8 as f64);
+  println!("{}", 1u8 as int);
+  println!("{}", 1u8 as uint);
+  println!("{}", 1u8 as *libc::FILE);
+  println!("{}", 1u8 as i8);
+  println!("{}", 1u8 as i16);
+  println!("{}", 1u8 as i32);
+  println!("{}", 1u8 as i64);
+  println!("{}", 1u8 as u8);
+  println!("{}", 1u8 as u16);
+  println!("{}", 1u8 as u32);
+  println!("{}", 1u8 as u64);
+  println!("{}", 1u8 as f32);
+  println!("{}", 1u8 as f64);
 
-  info!("{}", 1i16 as int);
-  info!("{}", 1i16 as uint);
-  info!("{}", 1i16 as *libc::FILE);
-  info!("{}", 1i16 as i8);
-  info!("{}", 1i16 as i16);
-  info!("{}", 1i16 as i32);
-  info!("{}", 1i16 as i64);
-  info!("{}", 1i16 as u8);
-  info!("{}", 1i16 as u16);
-  info!("{}", 1i16 as u32);
-  info!("{}", 1i16 as u64);
-  info!("{}", 1i16 as f32);
-  info!("{}", 1i16 as f64);
+  println!("{}", 1i16 as int);
+  println!("{}", 1i16 as uint);
+  println!("{}", 1i16 as *libc::FILE);
+  println!("{}", 1i16 as i8);
+  println!("{}", 1i16 as i16);
+  println!("{}", 1i16 as i32);
+  println!("{}", 1i16 as i64);
+  println!("{}", 1i16 as u8);
+  println!("{}", 1i16 as u16);
+  println!("{}", 1i16 as u32);
+  println!("{}", 1i16 as u64);
+  println!("{}", 1i16 as f32);
+  println!("{}", 1i16 as f64);
 
-  info!("{}", 1u16 as int);
-  info!("{}", 1u16 as uint);
-  info!("{}", 1u16 as *libc::FILE);
-  info!("{}", 1u16 as i8);
-  info!("{}", 1u16 as i16);
-  info!("{}", 1u16 as i32);
-  info!("{}", 1u16 as i64);
-  info!("{}", 1u16 as u8);
-  info!("{}", 1u16 as u16);
-  info!("{}", 1u16 as u32);
-  info!("{}", 1u16 as u64);
-  info!("{}", 1u16 as f32);
-  info!("{}", 1u16 as f64);
+  println!("{}", 1u16 as int);
+  println!("{}", 1u16 as uint);
+  println!("{}", 1u16 as *libc::FILE);
+  println!("{}", 1u16 as i8);
+  println!("{}", 1u16 as i16);
+  println!("{}", 1u16 as i32);
+  println!("{}", 1u16 as i64);
+  println!("{}", 1u16 as u8);
+  println!("{}", 1u16 as u16);
+  println!("{}", 1u16 as u32);
+  println!("{}", 1u16 as u64);
+  println!("{}", 1u16 as f32);
+  println!("{}", 1u16 as f64);
 
-  info!("{}", 1i32 as int);
-  info!("{}", 1i32 as uint);
-  info!("{}", 1i32 as *libc::FILE);
-  info!("{}", 1i32 as i8);
-  info!("{}", 1i32 as i16);
-  info!("{}", 1i32 as i32);
-  info!("{}", 1i32 as i64);
-  info!("{}", 1i32 as u8);
-  info!("{}", 1i32 as u16);
-  info!("{}", 1i32 as u32);
-  info!("{}", 1i32 as u64);
-  info!("{}", 1i32 as f32);
-  info!("{}", 1i32 as f64);
+  println!("{}", 1i32 as int);
+  println!("{}", 1i32 as uint);
+  println!("{}", 1i32 as *libc::FILE);
+  println!("{}", 1i32 as i8);
+  println!("{}", 1i32 as i16);
+  println!("{}", 1i32 as i32);
+  println!("{}", 1i32 as i64);
+  println!("{}", 1i32 as u8);
+  println!("{}", 1i32 as u16);
+  println!("{}", 1i32 as u32);
+  println!("{}", 1i32 as u64);
+  println!("{}", 1i32 as f32);
+  println!("{}", 1i32 as f64);
 
-  info!("{}", 1u32 as int);
-  info!("{}", 1u32 as uint);
-  info!("{}", 1u32 as *libc::FILE);
-  info!("{}", 1u32 as i8);
-  info!("{}", 1u32 as i16);
-  info!("{}", 1u32 as i32);
-  info!("{}", 1u32 as i64);
-  info!("{}", 1u32 as u8);
-  info!("{}", 1u32 as u16);
-  info!("{}", 1u32 as u32);
-  info!("{}", 1u32 as u64);
-  info!("{}", 1u32 as f32);
-  info!("{}", 1u32 as f64);
+  println!("{}", 1u32 as int);
+  println!("{}", 1u32 as uint);
+  println!("{}", 1u32 as *libc::FILE);
+  println!("{}", 1u32 as i8);
+  println!("{}", 1u32 as i16);
+  println!("{}", 1u32 as i32);
+  println!("{}", 1u32 as i64);
+  println!("{}", 1u32 as u8);
+  println!("{}", 1u32 as u16);
+  println!("{}", 1u32 as u32);
+  println!("{}", 1u32 as u64);
+  println!("{}", 1u32 as f32);
+  println!("{}", 1u32 as f64);
 
-  info!("{}", 1i64 as int);
-  info!("{}", 1i64 as uint);
-  info!("{}", 1i64 as *libc::FILE);
-  info!("{}", 1i64 as i8);
-  info!("{}", 1i64 as i16);
-  info!("{}", 1i64 as i32);
-  info!("{}", 1i64 as i64);
-  info!("{}", 1i64 as u8);
-  info!("{}", 1i64 as u16);
-  info!("{}", 1i64 as u32);
-  info!("{}", 1i64 as u64);
-  info!("{}", 1i64 as f32);
-  info!("{}", 1i64 as f64);
+  println!("{}", 1i64 as int);
+  println!("{}", 1i64 as uint);
+  println!("{}", 1i64 as *libc::FILE);
+  println!("{}", 1i64 as i8);
+  println!("{}", 1i64 as i16);
+  println!("{}", 1i64 as i32);
+  println!("{}", 1i64 as i64);
+  println!("{}", 1i64 as u8);
+  println!("{}", 1i64 as u16);
+  println!("{}", 1i64 as u32);
+  println!("{}", 1i64 as u64);
+  println!("{}", 1i64 as f32);
+  println!("{}", 1i64 as f64);
 
-  info!("{}", 1u64 as int);
-  info!("{}", 1u64 as uint);
-  info!("{}", 1u64 as *libc::FILE);
-  info!("{}", 1u64 as i8);
-  info!("{}", 1u64 as i16);
-  info!("{}", 1u64 as i32);
-  info!("{}", 1u64 as i64);
-  info!("{}", 1u64 as u8);
-  info!("{}", 1u64 as u16);
-  info!("{}", 1u64 as u32);
-  info!("{}", 1u64 as u64);
-  info!("{}", 1u64 as f32);
-  info!("{}", 1u64 as f64);
+  println!("{}", 1u64 as int);
+  println!("{}", 1u64 as uint);
+  println!("{}", 1u64 as *libc::FILE);
+  println!("{}", 1u64 as i8);
+  println!("{}", 1u64 as i16);
+  println!("{}", 1u64 as i32);
+  println!("{}", 1u64 as i64);
+  println!("{}", 1u64 as u8);
+  println!("{}", 1u64 as u16);
+  println!("{}", 1u64 as u32);
+  println!("{}", 1u64 as u64);
+  println!("{}", 1u64 as f32);
+  println!("{}", 1u64 as f64);
 
-  info!("{}", 1u64 as int);
-  info!("{}", 1u64 as uint);
-  info!("{}", 1u64 as *libc::FILE);
-  info!("{}", 1u64 as i8);
-  info!("{}", 1u64 as i16);
-  info!("{}", 1u64 as i32);
-  info!("{}", 1u64 as i64);
-  info!("{}", 1u64 as u8);
-  info!("{}", 1u64 as u16);
-  info!("{}", 1u64 as u32);
-  info!("{}", 1u64 as u64);
-  info!("{}", 1u64 as f32);
-  info!("{}", 1u64 as f64);
+  println!("{}", 1u64 as int);
+  println!("{}", 1u64 as uint);
+  println!("{}", 1u64 as *libc::FILE);
+  println!("{}", 1u64 as i8);
+  println!("{}", 1u64 as i16);
+  println!("{}", 1u64 as i32);
+  println!("{}", 1u64 as i64);
+  println!("{}", 1u64 as u8);
+  println!("{}", 1u64 as u16);
+  println!("{}", 1u64 as u32);
+  println!("{}", 1u64 as u64);
+  println!("{}", 1u64 as f32);
+  println!("{}", 1u64 as f64);
 
-  info!("{}", true as int);
-  info!("{}", true as uint);
-  info!("{}", true as *libc::FILE);
-  info!("{}", true as i8);
-  info!("{}", true as i16);
-  info!("{}", true as i32);
-  info!("{}", true as i64);
-  info!("{}", true as u8);
-  info!("{}", true as u16);
-  info!("{}", true as u32);
-  info!("{}", true as u64);
-  info!("{}", true as f32);
-  info!("{}", true as f64);
+  println!("{}", true as int);
+  println!("{}", true as uint);
+  println!("{}", true as *libc::FILE);
+  println!("{}", true as i8);
+  println!("{}", true as i16);
+  println!("{}", true as i32);
+  println!("{}", true as i64);
+  println!("{}", true as u8);
+  println!("{}", true as u16);
+  println!("{}", true as u32);
+  println!("{}", true as u64);
+  println!("{}", true as f32);
+  println!("{}", true as f64);
 
-  info!("{}", 1. as int);
-  info!("{}", 1. as uint);
-  info!("{}", 1. as i8);
-  info!("{}", 1. as i16);
-  info!("{}", 1. as i32);
-  info!("{}", 1. as i64);
-  info!("{}", 1. as u8);
-  info!("{}", 1. as u16);
-  info!("{}", 1. as u32);
-  info!("{}", 1. as u64);
-  info!("{}", 1. as f32);
-  info!("{}", 1. as f64);
+  println!("{}", 1. as int);
+  println!("{}", 1. as uint);
+  println!("{}", 1. as i8);
+  println!("{}", 1. as i16);
+  println!("{}", 1. as i32);
+  println!("{}", 1. as i64);
+  println!("{}", 1. as u8);
+  println!("{}", 1. as u16);
+  println!("{}", 1. as u32);
+  println!("{}", 1. as u64);
+  println!("{}", 1. as f32);
+  println!("{}", 1. as f64);
 
-  info!("{}", 1f32 as int);
-  info!("{}", 1f32 as uint);
-  info!("{}", 1f32 as i8);
-  info!("{}", 1f32 as i16);
-  info!("{}", 1f32 as i32);
-  info!("{}", 1f32 as i64);
-  info!("{}", 1f32 as u8);
-  info!("{}", 1f32 as u16);
-  info!("{}", 1f32 as u32);
-  info!("{}", 1f32 as u64);
-  info!("{}", 1f32 as f32);
-  info!("{}", 1f32 as f64);
+  println!("{}", 1f32 as int);
+  println!("{}", 1f32 as uint);
+  println!("{}", 1f32 as i8);
+  println!("{}", 1f32 as i16);
+  println!("{}", 1f32 as i32);
+  println!("{}", 1f32 as i64);
+  println!("{}", 1f32 as u8);
+  println!("{}", 1f32 as u16);
+  println!("{}", 1f32 as u32);
+  println!("{}", 1f32 as u64);
+  println!("{}", 1f32 as f32);
+  println!("{}", 1f32 as f64);
 
-  info!("{}", 1f64 as int);
-  info!("{}", 1f64 as uint);
-  info!("{}", 1f64 as i8);
-  info!("{}", 1f64 as i16);
-  info!("{}", 1f64 as i32);
-  info!("{}", 1f64 as i64);
-  info!("{}", 1f64 as u8);
-  info!("{}", 1f64 as u16);
-  info!("{}", 1f64 as u32);
-  info!("{}", 1f64 as u64);
-  info!("{}", 1f64 as f32);
-  info!("{}", 1f64 as f64);
+  println!("{}", 1f64 as int);
+  println!("{}", 1f64 as uint);
+  println!("{}", 1f64 as i8);
+  println!("{}", 1f64 as i16);
+  println!("{}", 1f64 as i32);
+  println!("{}", 1f64 as i64);
+  println!("{}", 1f64 as u8);
+  println!("{}", 1f64 as u16);
+  println!("{}", 1f64 as u32);
+  println!("{}", 1f64 as u64);
+  println!("{}", 1f64 as f32);
+  println!("{}", 1f64 as f64);
 }
diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs
index 78cc48e4ed4..781a50b87a7 100644
--- a/src/test/run-pass/tag-align-shape.rs
+++ b/src/test/run-pass/tag-align-shape.rs
@@ -22,6 +22,6 @@ struct t_rec {
 pub fn main() {
     let x = t_rec {c8: 22u8, t: a_tag(44u64)};
     let y = format!("{:?}", x);
-    info!("y = {}", y);
+    println!("y = {}", y);
     assert_eq!(y, ~"t_rec{c8: 22u8, t: a_tag(44u64)}");
 }
diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs
index 05b3f98ea08..5cf6c2af12b 100644
--- a/src/test/run-pass/tail-cps.rs
+++ b/src/test/run-pass/tail-cps.rs
@@ -16,13 +16,13 @@ fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }
 pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
 
 fn evenk(n: int, k: fn(bool) -> bool) -> bool {
-    info!("evenk");
-    info!("{:?}", n);
+    println!("evenk");
+    println!("{:?}", n);
     if n == 0 { return k(true); } else { return oddk(n - 1, k); }
 }
 
 fn oddk(n: int, k: fn(bool) -> bool) -> bool {
-    info!("oddk");
-    info!("{:?}", n);
+    println!("oddk");
+    println!("{:?}", n);
     if n == 0 { return k(false); } else { return 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 cbab11003b1..55235974e13 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -16,21 +16,21 @@ pub fn main() { test05(); }
 
 fn test05_start(tx : &Sender<int>) {
     tx.send(10);
-    error!("sent 10");
+    println!("sent 10");
     tx.send(20);
-    error!("sent 20");
+    println!("sent 20");
     tx.send(30);
-    error!("sent 30");
+    println!("sent 30");
 }
 
 fn test05() {
     let (tx, rx) = channel();
     task::spawn(proc() { test05_start(&tx) });
     let mut value: int = rx.recv();
-    error!("{}", value);
+    println!("{}", value);
     value = rx.recv();
-    error!("{}", value);
+    println!("{}", value);
     value = rx.recv();
-    error!("{}", value);
+    println!("{}", value);
     assert_eq!(value, 30);
 }
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index 830aecfa86c..8eaa7f2e31d 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -12,9 +12,9 @@ use std::task;
 
 pub fn main() { test00(); }
 
-fn start() { info!("Started / Finished task."); }
+fn start() { println!("Started / Finished task."); }
 
 fn test00() {
     task::try(proc() start() );
-    info!("Completing.");
+    println!("Completing.");
 }
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 844e39e584e..6299cfdee20 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -20,10 +20,10 @@ fn start(tx: &Sender<Sender<~str>>) {
     let mut b;
     a = rx.recv();
     assert!(a == ~"A");
-    error!("{:?}", a);
+    println!("{:?}", a);
     b = rx.recv();
     assert!(b == ~"B");
-    error!("{:?}", b);
+    println!("{:?}", b);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index d0c5efbfa22..275c99f99a9 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -12,7 +12,7 @@ use std::task;
 
 pub fn main() { test00(); }
 
-fn start(_task_number: int) { info!("Started / Finished task."); }
+fn start(_task_number: int) { println!("Started / Finished task."); }
 
 fn test00() {
     let i: int = 0;
@@ -32,5 +32,5 @@ fn test00() {
     // Try joining tasks that have already finished.
     result.recv();
 
-    info!("Joined task.");
+    println!("Joined task.");
 }
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index 0b1e9580a1e..6d06578c6cd 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -18,8 +18,8 @@ fn start(tx: &Sender<int>, start: int, number_of_messages: int) {
 }
 
 pub fn main() {
-    info!("Check that we don't deadlock.");
+    println!("Check that we don't deadlock.");
     let (tx, rx) = channel();
     task::try(proc() { start(&tx, 0, 10) });
-    info!("Joined task");
+    println!("Joined task");
 }
diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index 799ee609300..9559e5c84af 100644
--- a/src/test/run-pass/task-comm-14.rs
+++ b/src/test/run-pass/task-comm-14.rs
@@ -18,7 +18,7 @@ pub fn main() {
     // Spawn 10 tasks each sending us back one int.
     let mut i = 10;
     while (i > 0) {
-        info!("{}", i);
+        println!("{}", i);
         let tx = tx.clone();
         task::spawn({let i = i; proc() { child(i, &tx) }});
         i = i - 1;
@@ -29,15 +29,15 @@ pub fn main() {
 
     i = 10;
     while (i > 0) {
-        info!("{}", i);
+        println!("{}", i);
         rx.recv();
         i = i - 1;
     }
 
-    info!("main thread exiting");
+    println!("main thread exiting");
 }
 
 fn child(x: int, tx: &Sender<int>) {
-    info!("{}", x);
+    println!("{}", x);
     tx.send(x);
 }
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 0ed76593b9e..176b64e41d0 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -12,24 +12,24 @@
 
 use std::task;
 
-pub fn main() { info!("===== WITHOUT THREADS ====="); test00(); }
+pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
 
 fn test00_start(ch: &Sender<int>, message: int, count: int) {
-    info!("Starting test00_start");
+    println!("Starting test00_start");
     let mut i: int = 0;
     while i < count {
-        info!("Sending Message");
+        println!("Sending Message");
         ch.send(message + 0);
         i = i + 1;
     }
-    info!("Ending test00_start");
+    println!("Ending test00_start");
 }
 
 fn test00() {
     let number_of_tasks: int = 16;
     let number_of_messages: int = 4;
 
-    info!("Creating tasks");
+    println!("Creating tasks");
 
     let (tx, rx) = channel();
 
@@ -64,8 +64,8 @@ fn test00() {
     // Join spawned tasks...
     for r in results.iter() { r.recv(); }
 
-    info!("Completed: Final number is: ");
-    error!("{:?}", sum);
+    println!("Completed: Final number is: ");
+    println!("{:?}", sum);
     // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
     //       number_of_messages));
     assert_eq!(sum, 480);
diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs
index 411730dac78..6418921172a 100644
--- a/src/test/run-pass/task-comm-4.rs
+++ b/src/test/run-pass/task-comm-4.rs
@@ -22,31 +22,31 @@ fn test00() {
     tx.send(4);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     tx.send(5);
     tx.send(6);
     tx.send(7);
     tx.send(8);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     r = rx.recv();
     sum += r;
-    info!("{}", r);
+    println!("{}", r);
     assert_eq!(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 f2493e5d102..a4e6be4f2d5 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -34,7 +34,7 @@ fn test00() {
     let mut i: int = 0;
     while i < number_of_messages {
         sum += rx.recv();
-        info!("{:?}", r);
+        println!("{:?}", r);
         i += 1;
     }
 
diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs
index 2bb839aa2cf..873269190c5 100644
--- a/src/test/run-pass/tempfile.rs
+++ b/src/test/run-pass/tempfile.rs
@@ -80,7 +80,7 @@ fn test_rm_tempdir() {
 fn recursive_mkdir_rel() {
     let path = Path::new("frob");
     let cwd = os::getcwd();
-    debug!("recursive_mkdir_rel: Making: {} in cwd {} [{:?}]", path.display(),
+    println!("recursive_mkdir_rel: Making: {} in cwd {} [{:?}]", path.display(),
            cwd.display(), path.exists());
     fs::mkdir_recursive(&path, io::UserRWX);
     assert!(path.is_dir());
@@ -98,13 +98,13 @@ fn recursive_mkdir_dot() {
 fn recursive_mkdir_rel_2() {
     let path = Path::new("./frob/baz");
     let cwd = os::getcwd();
-    debug!("recursive_mkdir_rel_2: Making: {} in cwd {} [{:?}]", path.display(),
+    println!("recursive_mkdir_rel_2: Making: {} in cwd {} [{:?}]", path.display(),
            cwd.display(), path.exists());
     fs::mkdir_recursive(&path, io::UserRWX);
     assert!(path.is_dir());
     assert!(path.dir_path().is_dir());
     let path2 = Path::new("quux/blat");
-    debug!("recursive_mkdir_rel_2: Making: {} in cwd {}", path2.display(),
+    println!("recursive_mkdir_rel_2: Making: {} in cwd {}", path2.display(),
            cwd.display());
     fs::mkdir_recursive(&path2, io::UserRWX);
     assert!(path2.is_dir());
@@ -120,7 +120,7 @@ pub fn test_rmdir_recursive_ok() {
     let tmpdir = tmpdir.path();
     let root = tmpdir.join("foo");
 
-    debug!("making {}", root.display());
+    println!("making {}", root.display());
     fs::mkdir(&root, rwx);
     fs::mkdir(&root.join("foo"), rwx);
     fs::mkdir(&root.join("foo").join("bar"), rwx);
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index b00689db26b..dc862f201c2 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -13,7 +13,7 @@ use std::task;
 pub fn main() {
     let mut i = 10;
     while i > 0 { task::spawn({let i = i; proc() child(i)}); i = i - 1; }
-    info!("main thread exiting");
+    println!("main thread exiting");
 }
 
-fn child(x: int) { info!("{}", x); }
+fn child(x: int) { println!("{}", x); }
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index a9e2979f7db..840ab18dafa 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let (tx, rx) = channel();
     tx.send(42);
     let r = rx.recv();
-    error!("{:?}", r);
+    println!("{:?}", r);
 }
diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs
index a0c2a489bf6..11d1b9ecbfe 100644
--- a/src/test/run-pass/typeclasses-eq-example-static.rs
+++ b/src/test/run-pass/typeclasses-eq-example-static.rs
@@ -63,5 +63,5 @@ pub fn main() {
     assert!(!Equal::isEq(branch(@leaf(magenta), @leaf(cyan)),
                  branch(@leaf(magenta), @leaf(magenta))));
 
-    error!("Assertions all succeeded!");
+    println!("Assertions all succeeded!");
 }
diff --git a/src/test/run-pass/typeclasses-eq-example.rs b/src/test/run-pass/typeclasses-eq-example.rs
index 50af6cb71c1..ed72a758c78 100644
--- a/src/test/run-pass/typeclasses-eq-example.rs
+++ b/src/test/run-pass/typeclasses-eq-example.rs
@@ -62,5 +62,5 @@ pub fn main() {
     assert!(!branch(@leaf(magenta), @leaf(cyan))
         .isEq(branch(@leaf(magenta), @leaf(magenta))));
 
-    error!("Assertions all succeeded!");
+    println!("Assertions all succeeded!");
 }
diff --git a/src/test/run-pass/unary-minus-suffix-inference.rs b/src/test/run-pass/unary-minus-suffix-inference.rs
index 4898ef1cd0a..adbbf1aec9a 100644
--- a/src/test/run-pass/unary-minus-suffix-inference.rs
+++ b/src/test/run-pass/unary-minus-suffix-inference.rs
@@ -11,43 +11,43 @@
 pub fn main() {
     let a = 1;
     let a_neg: i8 = -a;
-    error!("{}", a_neg);
+    println!("{}", a_neg);
 
     let b = 1;
     let b_neg: i16 = -b;
-    error!("{}", b_neg);
+    println!("{}", b_neg);
 
     let c = 1;
     let c_neg: i32 = -c;
-    error!("{}", c_neg);
+    println!("{}", c_neg);
 
     let d = 1;
     let d_neg: i64 = -d;
-    error!("{}", d_neg);
+    println!("{}", d_neg);
 
     let e = 1;
     let e_neg: int = -e;
-    error!("{}", e_neg);
+    println!("{}", e_neg);
 
     // intentional overflows
 
     let f = 1;
     let f_neg: u8 = -f;
-    error!("{}", f_neg);
+    println!("{}", f_neg);
 
     let g = 1;
     let g_neg: u16 = -g;
-    error!("{}", g_neg);
+    println!("{}", g_neg);
 
     let h = 1;
     let h_neg: u32 = -h;
-    error!("{}", h_neg);
+    println!("{}", h_neg);
 
     let i = 1;
     let i_neg: u64 = -i;
-    error!("{}", i_neg);
+    println!("{}", i_neg);
 
     let j = 1;
     let j_neg: uint = -j;
-    error!("{}", j_neg);
+    println!("{}", j_neg);
 }
diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs
index 48a49996aee..7bb0fe5faa1 100644
--- a/src/test/run-pass/unique-copy-box.rs
+++ b/src/test/run-pass/unique-copy-box.rs
@@ -19,6 +19,6 @@ pub fn main() {
     let rc1 = managed::refcount(*i);
     let j = i.clone();
     let rc2 = managed::refcount(*i);
-    error!("rc1: {} rc2: {}", rc1, rc2);
+    println!("rc1: {} rc2: {}", rc1, rc2);
     assert_eq!(rc1 + 1u, rc2);
 }
diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs
index b1fc4e76ea0..c5d55ff0386 100644
--- a/src/test/run-pass/unique-in-tag.rs
+++ b/src/test/run-pass/unique-in-tag.rs
@@ -14,7 +14,7 @@ fn test1() {
     let x = u(~10);
     assert!(match x {
       u(a) => {
-        error!("{:?}", a);
+        println!("{:?}", a);
         *a
       }
       _ => { 66 }
diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs
index 96d61b377af..06f73777032 100644
--- a/src/test/run-pass/unique-log.rs
+++ b/src/test/run-pass/unique-log.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let i = ~100;
-    error!("{:?}", i);
+    println!("{:?}", i);
 }
diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs
index 077bbdfb0ba..7f11e7b7df5 100644
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -14,7 +14,7 @@ enum bar { u(~int), w(int), }
 pub fn main() {
     assert!(match u(~10) {
       u(a) => {
-        error!("{:?}", a);
+        println!("{:?}", a);
         *a
       }
       _ => { 66 }
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index fc37e1c39ed..2d05eb22196 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -18,14 +18,14 @@ struct complainer {
 
 impl Drop for complainer {
     fn drop(&mut self) {
-        error!("About to send!");
+        println!("About to send!");
         self.tx.send(true);
-        error!("Sent!");
+        println!("Sent!");
     }
 }
 
 fn complainer(tx: Sender<bool>) -> complainer {
-    error!("Hello!");
+    println!("Hello!");
     complainer {
         tx: tx
     }
@@ -39,6 +39,6 @@ fn f(tx: Sender<bool>) {
 pub fn main() {
     let (tx, rx) = channel();
     task::spawn(proc() f(tx.clone()));
-    error!("hiiiiiiiii");
+    println!("hiiiiiiiii");
     assert!(rx.recv());
 }
diff --git a/src/test/run-pass/use-uninit-match.rs b/src/test/run-pass/use-uninit-match.rs
index 69e28e30d09..a5659a4648e 100644
--- a/src/test/run-pass/use-uninit-match.rs
+++ b/src/test/run-pass/use-uninit-match.rs
@@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 enum myoption<T> { none, some(T), }
 
-pub fn main() { info!("{}", 5); }
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/use-uninit-match2.rs b/src/test/run-pass/use-uninit-match2.rs
index a85861d2aa5..9bf98baa303 100644
--- a/src/test/run-pass/use-uninit-match2.rs
+++ b/src/test/run-pass/use-uninit-match2.rs
@@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 enum myoption<T> { none, some(T), }
 
-pub fn main() { info!("{}", 5); }
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
index 1520a8b7e61..9531563fcbe 100644
--- a/src/test/run-pass/utf8.rs
+++ b/src/test/run-pass/utf8.rs
@@ -42,10 +42,10 @@ pub fn main() {
     fn check_str_eq(a: ~str, b: ~str) {
         let mut i: int = 0;
         for ab in a.bytes() {
-            info!("{}", i);
-            info!("{}", ab);
+            println!("{}", i);
+            println!("{}", ab);
             let bb: u8 = b[i];
-            info!("{}", bb);
+            println!("{}", bb);
             assert_eq!(ab, bb);
             i += 1;
         }
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 7014ad5df14..9b42a25956e 100644
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -12,7 +12,7 @@ pub fn main() {
     let a: ~[int] = ~[1, 2, 3, 4, 5];
     let b: ~[int] = ~[6, 7, 8, 9, 0];
     let v: ~[int] = a + b;
-    info!("{}", v[9]);
+    println!("{}", v[9]);
     assert_eq!(v[0], 1);
     assert_eq!(v[7], 8);
     assert_eq!(v[9], 0);
diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs
index 7ffbade05c1..c15a7fcdf29 100644
--- a/src/test/run-pass/vec-late-init.rs
+++ b/src/test/run-pass/vec-late-init.rs
@@ -13,5 +13,5 @@
 pub fn main() {
     let mut later: ~[int];
     if true { later = ~[1]; } else { later = ~[2]; }
-    info!("{}", later[0]);
+    println!("{}", later[0]);
 }
diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index f190fd2cb93..cd20917a179 100644
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -45,7 +45,7 @@ fn test_loop() {
     let mut i = 20;
     let mut expected_len = 1u;
     while i > 0 {
-        error!("{}", a.len());
+        println!("{}", a.len());
         assert_eq!(a.len(), expected_len);
         a = a + a; // FIXME(#3387)---can't write a += a
         i -= 1;
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 10726a9c396..0e4f4194a54 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -66,7 +66,7 @@ fn canttouchthis() -> uint {
     fn p() -> bool { true }
     let _a = (assert!((true)) == (assert!(p())));
     let _c = (assert!((p())) == ());
-    let _b: bool = (info!("{}", 0) == (return 0u));
+    let _b: bool = (println!("{}", 0) == (return 0u));
 }
 
 fn angrydome() {
@@ -76,7 +76,7 @@ fn angrydome() {
       break; }
 }
 
-fn evil_lincoln() { let _evil = info!("lincoln"); }
+fn evil_lincoln() { let _evil = println!("lincoln"); }
 
 pub fn main() {
     strange();
diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs
index ed7ba12ea0f..3e1a232115f 100644
--- a/src/test/run-pass/while-cont.rs
+++ b/src/test/run-pass/while-cont.rs
@@ -13,7 +13,7 @@ pub fn main() {
     let mut i = 1;
     while i > 0 {
         assert!((i > 0));
-        info!("{}", i);
+        println!("{}", i);
         i -= 1;
         continue;
     }
diff --git a/src/test/run-pass/while-loop-constraints-2.rs b/src/test/run-pass/while-loop-constraints-2.rs
index a21aa4a9a62..8ef98901e9f 100644
--- a/src/test/run-pass/while-loop-constraints-2.rs
+++ b/src/test/run-pass/while-loop-constraints-2.rs
@@ -18,7 +18,7 @@ pub fn main() {
     while z < 50 {
         z += 1;
         while false { x = y; y = z; }
-        info!("{}", y);
+        println!("{}", 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 57bc3bda963..1f16b5fdb5c 100644
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -12,13 +12,13 @@
 pub fn main() {
     let mut i: int = 90;
     while i < 100 {
-        info!("{}", i);
+        println!("{}", i);
         i = i + 1;
         if i == 95 {
             let _v: ~[int] =
                 ~[1, 2, 3, 4, 5]; // we check that it is freed by break
 
-            info!("breaking");
+            println!("breaking");
             break;
         }
     }
diff --git a/src/test/run-pass/while.rs b/src/test/run-pass/while.rs
index fe2506ad686..bd8b1f0f088 100644
--- a/src/test/run-pass/while.rs
+++ b/src/test/run-pass/while.rs
@@ -13,10 +13,10 @@
 pub fn main() {
     let mut x: int = 10;
     let mut y: int = 0;
-    while y < x { info!("{}", y); info!("hello"); y = y + 1; }
+    while y < x { println!("{}", y); println!("hello"); y = y + 1; }
     while x > 0 {
-        info!("goodbye");
+        println!("goodbye");
         x = x - 1;
-        info!("{}", x);
+        println!("{}", x);
     }
 }
diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs
index 01370ed12b4..b2cf771faee 100644
--- a/src/test/run-pass/x86stdcall.rs
+++ b/src/test/run-pass/x86stdcall.rs
@@ -25,7 +25,7 @@ pub fn main() {
         let expected = 1234u;
         kernel32::SetLastError(expected);
         let actual = kernel32::GetLastError();
-        info!("actual = {}", actual);
+        println!("actual = {}", actual);
         assert_eq!(expected, actual);
     }
 }
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
index 4ec30d6e02a..bd44bdd51cd 100644
--- a/src/test/run-pass/yield.rs
+++ b/src/test/run-pass/yield.rs
@@ -14,14 +14,14 @@ pub fn main() {
     let mut builder = task::task();
     let mut result = builder.future_result();
     builder.spawn(child);
-    error!("1");
+    println!("1");
     task::deschedule();
-    error!("2");
+    println!("2");
     task::deschedule();
-    error!("3");
+    println!("3");
     result.recv();
 }
 
 fn child() {
-    error!("4"); task::deschedule(); error!("5"); task::deschedule(); error!("6");
+    println!("4"); task::deschedule(); println!("5"); task::deschedule(); println!("6");
 }
diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs
index c08c62b47a2..14ba368bdfa 100644
--- a/src/test/run-pass/yield1.rs
+++ b/src/test/run-pass/yield1.rs
@@ -14,9 +14,9 @@ pub fn main() {
     let mut builder = task::task();
     let mut result = builder.future_result();
     builder.spawn(child);
-    error!("1");
+    println!("1");
     task::deschedule();
     result.recv();
 }
 
-fn child() { error!("2"); }
+fn child() { println!("2"); }
diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs
index 7bc3c1fc1f4..c6cb0dd65e7 100644
--- a/src/test/run-pass/yield2.rs
+++ b/src/test/run-pass/yield2.rs
@@ -12,5 +12,5 @@ use std::task;
 
 pub fn main() {
     let mut i: int = 0;
-    while i < 100 { i = i + 1; error!("{}", i); task::deschedule(); }
+    while i < 100 { i = i + 1; println!("{}", i); task::deschedule(); }
 }