diff options
Diffstat (limited to 'src')
367 files changed, 1572 insertions, 1567 deletions
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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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); - - 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!("{}", 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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); + + 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(); } } |