From cc6ec8df95fbd8163b7c2c6c34469fb96b704e66 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 8 Mar 2014 22:11:44 -0800 Subject: [PATCH] log: Introduce liblog, the old std::logging This commit moves all logging out of the standard library into an external crate. This crate is the new crate which is responsible for all logging macros and logging implementation. A few reasons for this change are: * The crate map has always been a bit of a code smell among rust programs. It has difficulty being loaded on almost all platforms, and it's used almost exclusively for logging and only logging. Removing the crate map is one of the end goals of this movement. * The compiler has a fair bit of special support for logging. It has the __log_level() expression as well as generating a global word per module specifying the log level. This is unfairly favoring the built-in logging system, and is much better done purely in libraries instead of the compiler itself. * Initialization of logging is much easier to do if there is no reliance on a magical crate map being available to set module log levels. * If the logging library can be written outside of the standard library, there's no reason that it shouldn't be. It's likely that we're not going to build the highest quality logging library of all time, so third-party libraries should be able to provide just as high-quality logging systems as the default one provided in the rust distribution. With a migration such as this, the change does not come for free. There are some subtle changes in the behavior of liblog vs the previous logging macros: * The core change of this migration is that there is no longer a physical log-level per module. This concept is still emulated (it is quite useful), but there is now only a global log level, not a local one. This global log level is a reflection of the maximum of all log levels specified. The previously generated logging code looked like: if specified_level <= __module_log_level() { println!(...) } The newly generated code looks like: if specified_level <= ::log::LOG_LEVEL { if ::log::module_enabled(module_path!()) { println!(...) } } Notably, the first layer of checking is still intended to be "super fast" in that it's just a load of a global word and a compare. The second layer of checking is executed to determine if the current module does indeed have logging turned on. This means that if any module has a debug log level turned on, all modules with debug log levels get a little bit slower (they all do more expensive dynamic checks to determine if they're turned on or not). Semantically, this migration brings no change in this respect, but runtime-wise, this will have a perf impact on some code. * A `RUST_LOG=::help` directive will no longer print out a list of all modules that can be logged. This is because the crate map will no longer specify the log levels of all modules, so the list of modules is not known. Additionally, warnings can no longer be provided if a malformed logging directive was supplied. The new "hello world" for logging looks like: #[phase(syntax, link)] extern crate log; fn main() { debug!("Hello, world!"); } --- mk/crates.mk | 9 +- src/compiletest/compiletest.rs | 3 + src/doc/rust.md | 5 +- src/doc/tutorial.md | 6 +- src/libcollections/lib.rs | 3 +- src/libflate/lib.rs | 4 +- src/libgetopts/lib.rs | 4 +- src/libgreen/lib.rs | 3 +- src/libgreen/task.rs | 3 +- src/liblog/directive.rs | 134 ++++++ src/liblog/lib.rs | 340 +++++++++++++++ src/liblog/macros.rs | 141 ++++++ src/libnative/io/file_unix.rs | 6 +- src/libnative/io/mod.rs | 10 +- src/libnative/io/timer_timerfd.rs | 2 - src/libnative/task.rs | 3 +- src/librustc/back/link.rs | 10 +- src/librustc/driver/driver.rs | 58 ++- src/librustc/front/test.rs | 1 + src/librustc/lib.rs | 6 +- src/librustc/middle/trans/base.rs | 2 +- src/librustdoc/core.rs | 4 +- src/librustdoc/lib.rs | 4 +- src/librustdoc/test.rs | 4 +- src/libsemver/lib.rs | 1 - src/libserialize/lib.rs | 4 +- src/libstd/cleanup.rs | 2 +- src/libstd/io/mod.rs | 4 +- src/libstd/io/test.rs | 9 +- src/libstd/iter.rs | 4 +- src/libstd/lib.rs | 5 +- src/libstd/logging.rs | 184 -------- src/libstd/macros.rs | 113 +---- src/libstd/os.rs | 10 +- src/libstd/ptr.rs | 3 - src/libstd/rt/logging.rs | 314 -------------- src/libstd/rt/mod.rs | 4 - src/libstd/rt/task.rs | 5 - src/libstd/task.rs | 4 - src/libsync/lib.rs | 3 + src/libsyntax/ast_map.rs | 3 +- src/libsyntax/ext/base.rs | 7 +- src/libsyntax/ext/expand.rs | 6 + src/libsyntax/lib.rs | 6 +- src/libsyntax/parse/token.rs | 59 ++- src/libterm/lib.rs | 12 - src/libterm/terminfo/parser/compiled.rs | 26 -- src/libtest/lib.rs | 15 - src/libtime/lib.rs | 3 +- src/test/auxiliary/cci_class_4.rs | 6 +- src/test/auxiliary/cci_class_cast.rs | 6 +- .../auxiliary/extern-crosscrate-source.rs | 2 +- src/test/auxiliary/logging_right_crate.rs | 3 + src/test/bench/core-uint-to-str.rs | 2 +- src/test/bench/msgsend-pipes-shared.rs | 12 +- src/test/bench/msgsend-pipes.rs | 16 +- src/test/bench/msgsend-ring-mutex-arcs.rs | 4 +- src/test/bench/msgsend-ring-rw-arcs.rs | 4 +- src/test/bench/shootout-pfib.rs | 2 +- src/test/bench/shootout-threadring.rs | 2 +- src/test/bench/task-perf-alloc-unwind.rs | 6 +- src/test/bench/task-perf-one-million.rs | 2 +- src/test/compile-fail/asm-in-bad-modifier.rs | 2 +- src/test/compile-fail/asm-out-assign-imm.rs | 2 +- src/test/compile-fail/asm-out-no-modifier.rs | 2 +- src/test/compile-fail/asm-out-read-uninit.rs | 2 +- .../compile-fail/assign-imm-local-twice.rs | 4 +- src/test/compile-fail/assign-to-method.rs | 2 +- src/test/compile-fail/attr-before-ext.rs | 2 +- src/test/compile-fail/autoderef-full-lval.rs | 4 +- src/test/compile-fail/bad-const-type.rs | 2 +- ...her-can-live-while-the-other-survives-1.rs | 2 +- ...her-can-live-while-the-other-survives-2.rs | 2 +- ...her-can-live-while-the-other-survives-3.rs | 2 +- ...her-can-live-while-the-other-survives-4.rs | 2 +- .../bind-by-move-no-sub-bindings.rs | 2 +- src/test/compile-fail/block-coerce-no.rs | 2 +- src/test/compile-fail/bogus-tag.rs | 4 +- src/test/compile-fail/borrowck-and-init.rs | 4 +- .../compile-fail/borrowck-assign-comp-idx.rs | 2 +- src/test/compile-fail/borrowck-block-unint.rs | 2 +- .../borrowck-borrowed-uniq-rvalue-2.rs | 2 +- .../compile-fail/borrowck-break-uninit-2.rs | 4 +- .../compile-fail/borrowck-break-uninit.rs | 4 +- src/test/compile-fail/borrowck-if-no-else.rs | 2 +- .../compile-fail/borrowck-if-with-else.rs | 4 +- .../compile-fail/borrowck-init-in-fn-expr.rs | 2 +- .../borrowck-loan-blocks-move-cc.rs | 4 +- .../borrowck-move-out-of-vec-tail.rs | 2 +- .../borrowck-mut-addr-of-imm-var.rs | 2 +- src/test/compile-fail/borrowck-or-init.rs | 4 +- src/test/compile-fail/borrowck-uninit.rs | 2 +- src/test/compile-fail/borrowck-while-break.rs | 2 +- src/test/compile-fail/class-cast-to-trait.rs | 6 +- src/test/compile-fail/class-missing-self.rs | 2 +- src/test/compile-fail/copy-a-resource.rs | 2 +- src/test/compile-fail/dead-code-ret.rs | 2 +- ...d-deconstructing-destructing-struct-let.rs | 4 +- ...deconstructing-destructing-struct-match.rs | 4 +- src/test/compile-fail/does-nothing.rs | 2 +- src/test/compile-fail/export2.rs | 2 +- .../compile-fail/if-without-else-result.rs | 2 +- src/test/compile-fail/import-glob-0.rs | 8 +- src/test/compile-fail/import-glob-circular.rs | 4 +- src/test/compile-fail/import.rs | 2 +- src/test/compile-fail/import2.rs | 2 +- src/test/compile-fail/import3.rs | 2 +- src/test/compile-fail/import4.rs | 2 +- src/test/compile-fail/issue-1448-2.rs | 2 +- src/test/compile-fail/issue-1476.rs | 2 +- src/test/compile-fail/issue-2281-part1.rs | 2 +- src/test/compile-fail/issue-2823.rs | 2 +- src/test/compile-fail/issue-3038.rs | 4 +- src/test/compile-fail/issue-3099.rs | 2 +- src/test/compile-fail/issue-3521-2.rs | 2 +- src/test/compile-fail/issue-3521.rs | 2 +- src/test/compile-fail/liveness-bad-bang-2.rs | 2 +- .../liveness-closure-require-ret.rs | 2 +- .../compile-fail/liveness-move-in-loop.rs | 2 +- .../compile-fail/liveness-move-in-while.rs | 2 +- .../compile-fail/liveness-use-after-move.rs | 2 +- .../compile-fail/liveness-use-after-send.rs | 6 +- src/test/compile-fail/match-join.rs | 2 +- src/test/compile-fail/no-capture-arc.rs | 2 +- src/test/compile-fail/no-reuse-move-arc.rs | 2 +- src/test/compile-fail/no-send-res-ports.rs | 2 +- src/test/compile-fail/noncopyable-class.rs | 2 +- src/test/compile-fail/nonscalar-cast.rs | 2 +- src/test/compile-fail/oversized-literal.rs | 2 +- .../packed-struct-generic-transmute.rs | 2 +- .../compile-fail/packed-struct-transmute.rs | 2 +- src/test/compile-fail/pattern-tyvar.rs | 2 +- src/test/compile-fail/pinned-deep-copy.rs | 4 +- src/test/compile-fail/regions-addr-of-self.rs | 2 +- src/test/compile-fail/regions-freevar.rs | 2 +- .../compile-fail/regions-ret-borrowed-1.rs | 2 +- src/test/compile-fail/regions-ret-borrowed.rs | 2 +- src/test/compile-fail/unique-pinned-nocopy.rs | 2 +- src/test/compile-fail/unique-vec-res.rs | 4 +- src/test/compile-fail/unsupported-cast.rs | 2 +- src/test/compile-fail/vec-field.rs | 2 +- src/test/compile-fail/vec-res-add.rs | 2 +- src/test/run-fail/binop-fail-2.rs | 2 +- src/test/run-fail/binop-fail.rs | 2 +- .../bug-2470-bounds-check-overflow-2.rs | 4 +- .../bug-2470-bounds-check-overflow-3.rs | 6 +- .../bug-2470-bounds-check-overflow.rs | 10 +- src/test/run-fail/extern-fail.rs | 2 +- src/test/run-fail/fail-arg.rs | 2 +- src/test/run-fail/if-check-fail.rs | 2 +- src/test/run-fail/if-cond-bot.rs | 2 +- src/test/run-fail/match-wildcards.rs | 2 +- src/test/run-fail/result-get-fail.rs | 2 +- src/test/run-fail/rt-set-exit-status-fail.rs | 2 + src/test/run-fail/rt-set-exit-status-fail2.rs | 2 + src/test/run-fail/rt-set-exit-status.rs | 2 + .../run-fail/too-much-recursion-unwinding.rs | 2 +- src/test/run-fail/unwind-box-fn-unique.rs | 4 +- src/test/run-fail/unwind-box-res.rs | 2 +- src/test/run-fail/unwind-box-str.rs | 2 +- src/test/run-fail/unwind-box-unique-unique.rs | 2 +- src/test/run-fail/unwind-box-unique.rs | 2 +- src/test/run-fail/unwind-box-vec.rs | 2 +- .../run-make/c-set-crate-map-manually/lib.rs | 4 +- src/test/run-pass-fulldeps/qquote.rs | 2 +- src/test/run-pass/alignment-gep-tup-like-1.rs | 2 +- src/test/run-pass/arith-0.rs | 2 +- src/test/run-pass/arith-1.rs | 2 +- src/test/run-pass/auto-instantiate.rs | 4 +- src/test/run-pass/binops.rs | 2 +- src/test/run-pass/bitwise.rs | 4 +- src/test/run-pass/block-arg.rs | 2 +- src/test/run-pass/block-explicit-types.rs | 2 +- src/test/run-pass/block-iter-1.rs | 2 +- src/test/run-pass/block-iter-2.rs | 2 +- src/test/run-pass/borrowck-mut-uniq.rs | 4 +- .../borrowck-preserve-box-in-field.rs | 2 +- .../run-pass/borrowck-preserve-box-in-uniq.rs | 2 +- src/test/run-pass/borrowck-preserve-box.rs | 2 +- .../run-pass/borrowck-preserve-cond-box.rs | 4 +- .../run-pass/borrowck-preserve-expl-deref.rs | 2 +- src/test/run-pass/box-inside-if.rs | 2 +- src/test/run-pass/box-inside-if2.rs | 2 +- src/test/run-pass/box-unbox.rs | 2 +- src/test/run-pass/capturing-logging.rs | 6 +- src/test/run-pass/cast-region-to-uint.rs | 2 +- src/test/run-pass/cci_borrow.rs | 2 +- src/test/run-pass/cci_impl_exe.rs | 4 +- src/test/run-pass/cci_iter_exe.rs | 2 +- src/test/run-pass/cci_no_inline_exe.rs | 4 +- src/test/run-pass/class-attributes-1.rs | 2 +- src/test/run-pass/class-attributes-2.rs | 2 +- .../class-cast-to-trait-cross-crate-2.rs | 2 +- .../class-cast-to-trait-multiple-types.rs | 6 +- src/test/run-pass/class-cast-to-trait.rs | 6 +- .../class-impl-very-parameterized-trait.rs | 6 +- .../class-implement-trait-cross-crate.rs | 6 +- src/test/run-pass/class-implement-traits.rs | 6 +- src/test/run-pass/class-separate-impl.rs | 8 +- src/test/run-pass/classes.rs | 6 +- .../close-over-big-then-small-data.rs | 2 +- src/test/run-pass/comm.rs | 6 +- src/test/run-pass/complex.rs | 6 +- .../run-pass/conditional-debug-macro-off.rs | 6 +- .../run-pass/conditional-debug-macro-on.rs | 4 +- src/test/run-pass/const.rs | 2 +- src/test/run-pass/dead-code-one-arm-if.rs | 2 +- src/test/run-pass/deref-lval.rs | 2 +- src/test/run-pass/estr-slice.rs | 12 +- src/test/run-pass/evec-slice.rs | 8 +- src/test/run-pass/export-non-interference2.rs | 2 +- src/test/run-pass/export-non-interference3.rs | 2 +- src/test/run-pass/expr-block-generic-box1.rs | 4 +- .../run-pass/expr-block-generic-unique1.rs | 4 +- src/test/run-pass/extern-call-deep.rs | 4 +- src/test/run-pass/extern-call-deep2.rs | 4 +- src/test/run-pass/extern-call-indirect.rs | 4 +- src/test/run-pass/extern-call-scrub.rs | 4 +- src/test/run-pass/extern-crosscrate.rs | 4 +- src/test/run-pass/extern-yield.rs | 2 +- src/test/run-pass/fact.rs | 14 +- src/test/run-pass/fat-arrow-match.rs | 2 +- src/test/run-pass/float-signature.rs | 2 +- src/test/run-pass/float.rs | 4 +- src/test/run-pass/fn-bare-item.rs | 2 +- src/test/run-pass/foreach-put-structured.rs | 4 +- .../run-pass/foreach-simple-outer-slot.rs | 8 +- src/test/run-pass/generic-alias-box.rs | 2 +- src/test/run-pass/generic-alias-unique.rs | 2 +- src/test/run-pass/generic-derived-type.rs | 4 +- src/test/run-pass/generic-fn-box.rs | 2 +- src/test/run-pass/generic-fn-unique.rs | 2 +- src/test/run-pass/generic-fn.rs | 6 +- src/test/run-pass/generic-tag-match.rs | 2 +- src/test/run-pass/generic-tag-values.rs | 6 +- src/test/run-pass/generic-temporary.rs | 2 +- src/test/run-pass/generic-tup.rs | 2 +- src/test/run-pass/hashmap-memory.rs | 6 +- src/test/run-pass/if-bot.rs | 2 +- src/test/run-pass/if-check.rs | 2 +- src/test/run-pass/import-glob-0.rs | 12 +- src/test/run-pass/import.rs | 2 +- src/test/run-pass/import2.rs | 2 +- src/test/run-pass/import3.rs | 2 +- src/test/run-pass/import4.rs | 2 +- src/test/run-pass/import5.rs | 2 +- src/test/run-pass/import6.rs | 2 +- src/test/run-pass/import7.rs | 2 +- src/test/run-pass/import8.rs | 2 +- src/test/run-pass/inner-module.rs | 2 +- src/test/run-pass/integral-indexing.rs | 4 +- src/test/run-pass/issue-10626.rs | 2 +- src/test/run-pass/issue-1696.rs | 2 +- src/test/run-pass/issue-2216.rs | 2 +- src/test/run-pass/issue-2633.rs | 2 +- src/test/run-pass/issue-2718.rs | 8 +- src/test/run-pass/issue-2804-2.rs | 2 +- src/test/run-pass/issue-2804.rs | 6 +- src/test/run-pass/issue-2904.rs | 2 +- src/test/run-pass/issue-2935.rs | 2 +- src/test/run-pass/issue-3109.rs | 2 +- src/test/run-pass/issue-3609.rs | 2 +- src/test/run-pass/issue-4120.rs | 2 +- src/test/run-pass/issue-6344-let.rs | 2 +- src/test/run-pass/issue-6344-match.rs | 2 +- src/test/run-pass/issue-7563.rs | 6 +- src/test/run-pass/istr.rs | 6 +- src/test/run-pass/iter-range.rs | 2 +- src/test/run-pass/lambda-infer-unresolved.rs | 2 +- src/test/run-pass/last-use-is-capture.rs | 2 +- src/test/run-pass/lazy-and-or.rs | 2 +- src/test/run-pass/lazy-init.rs | 2 +- src/test/run-pass/linear-for-loop.rs | 8 +- src/test/run-pass/liveness-loop-break.rs | 2 +- src/test/run-pass/log-err-phi.rs | 2 +- src/test/run-pass/log-poly.rs | 8 +- src/test/run-pass/logging-enabled-debug.rs | 6 +- src/test/run-pass/logging-enabled.rs | 8 +- src/test/run-pass/logging-only-prints-once.rs | 2 +- src/test/run-pass/loop-break-cont.rs | 6 +- .../macro-with-braces-in-expr-position.rs | 4 +- src/test/run-pass/match-bot.rs | 2 +- src/test/run-pass/match-join.rs | 2 +- src/test/run-pass/match-pattern-drop.rs | 12 +- src/test/run-pass/match-pattern-lit.rs | 4 +- .../run-pass/match-pattern-no-type-params.rs | 4 +- src/test/run-pass/match-unique-bind.rs | 2 +- src/test/run-pass/match-with-ret-arm.rs | 2 +- src/test/run-pass/mutable-alias-vec.rs | 2 +- src/test/run-pass/nested-matchs.rs | 4 +- src/test/run-pass/nested-pattern.rs | 4 +- src/test/run-pass/opeq.rs | 8 +- src/test/run-pass/over-constrained-vregs.rs | 2 +- src/test/run-pass/paren-free.rs | 2 +- src/test/run-pass/parse-fail.rs | 2 +- src/test/run-pass/pass-by-copy.rs | 4 +- src/test/run-pass/preempt.rs | 14 +- src/test/run-pass/purity-infer.rs | 2 +- src/test/run-pass/rcvr-borrowed-to-region.rs | 6 +- src/test/run-pass/rcvr-borrowed-to-slice.rs | 6 +- src/test/run-pass/rec-align-u32.rs | 6 +- src/test/run-pass/rec-align-u64.rs | 6 +- src/test/run-pass/rec-auto.rs | 4 +- src/test/run-pass/reflect-visit-type.rs | 12 +- src/test/run-pass/regions-addr-of-ret.rs | 2 +- src/test/run-pass/regions-borrow-at.rs | 2 +- src/test/run-pass/regions-self-impls.rs | 2 +- src/test/run-pass/regions-self-in-enums.rs | 2 +- src/test/run-pass/regions-simple.rs | 2 +- src/test/run-pass/regions-static-closure.rs | 2 +- src/test/run-pass/repeated-vector-syntax.rs | 4 +- .../run-pass/resource-assign-is-not-copy.rs | 2 +- src/test/run-pass/resource-destruct.rs | 4 +- src/test/run-pass/ret-bang.rs | 2 +- src/test/run-pass/sendfn-spawn-with-fn-arg.rs | 2 +- src/test/run-pass/shadow.rs | 2 +- .../run-pass/shape_intrinsic_tag_then_rec.rs | 4 +- src/test/run-pass/simple-infer.rs | 2 +- src/test/run-pass/simple-match-generic-tag.rs | 2 +- src/test/run-pass/size-and-align.rs | 6 +- src/test/run-pass/spawn-fn.rs | 6 +- src/test/run-pass/spawn.rs | 2 +- src/test/run-pass/spawn2.rs | 18 +- src/test/run-pass/spawning-with-debug.rs | 2 +- src/test/run-pass/str-append.rs | 6 +- src/test/run-pass/str-concat.rs | 2 +- src/test/run-pass/str-idx.rs | 2 +- src/test/run-pass/string-self-append.rs | 2 +- src/test/run-pass/struct-literal-dtor.rs | 2 +- src/test/run-pass/struct-return.rs | 14 +- src/test/run-pass/supported-cast.rs | 404 +++++++++--------- src/test/run-pass/tag-align-shape.rs | 2 +- src/test/run-pass/tail-cps.rs | 8 +- src/test/run-pass/task-comm-0.rs | 12 +- src/test/run-pass/task-comm-1.rs | 4 +- src/test/run-pass/task-comm-10.rs | 4 +- src/test/run-pass/task-comm-12.rs | 4 +- src/test/run-pass/task-comm-13.rs | 4 +- src/test/run-pass/task-comm-14.rs | 8 +- src/test/run-pass/task-comm-3.rs | 14 +- src/test/run-pass/task-comm-4.rs | 16 +- src/test/run-pass/task-comm-9.rs | 2 +- src/test/run-pass/tempfile.rs | 8 +- src/test/run-pass/threads.rs | 4 +- src/test/run-pass/trivial-message.rs | 2 +- .../run-pass/typeclasses-eq-example-static.rs | 2 +- src/test/run-pass/typeclasses-eq-example.rs | 2 +- .../run-pass/unary-minus-suffix-inference.rs | 20 +- src/test/run-pass/unique-copy-box.rs | 2 +- src/test/run-pass/unique-in-tag.rs | 2 +- src/test/run-pass/unique-log.rs | 2 +- src/test/run-pass/unique-pat-3.rs | 2 +- src/test/run-pass/unwind-resource.rs | 8 +- src/test/run-pass/use-uninit-match.rs | 2 +- src/test/run-pass/use-uninit-match2.rs | 2 +- src/test/run-pass/utf8.rs | 6 +- src/test/run-pass/vec-concat.rs | 2 +- src/test/run-pass/vec-late-init.rs | 2 +- src/test/run-pass/vec-self-append.rs | 2 +- src/test/run-pass/weird-exprs.rs | 4 +- src/test/run-pass/while-cont.rs | 2 +- src/test/run-pass/while-loop-constraints-2.rs | 2 +- src/test/run-pass/while-with-break.rs | 4 +- src/test/run-pass/while.rs | 6 +- src/test/run-pass/x86stdcall.rs | 2 +- src/test/run-pass/yield.rs | 8 +- src/test/run-pass/yield1.rs | 4 +- src/test/run-pass/yield2.rs | 2 +- 368 files changed, 1562 insertions(+), 1556 deletions(-) create mode 100644 src/liblog/directive.rs create mode 100644 src/liblog/lib.rs create mode 100644 src/liblog/macros.rs delete mode 100644 src/libstd/logging.rs delete mode 100644 src/libstd/rt/logging.rs diff --git a/mk/crates.mk b/mk/crates.mk index 2a6e38a6d3d4..7c12b4edacb5 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -51,7 +51,7 @@ TARGET_CRATES := std green rustuv native flate arena glob term semver \ uuid serialize sync getopts collections num test time rand \ - workcache url + workcache url log HOST_CRATES := syntax rustc rustdoc fourcc hexfloat CRATES := $(TARGET_CRATES) $(HOST_CRATES) TOOLS := compiletest rustdoc rustc @@ -60,15 +60,15 @@ DEPS_std := native:rustrt native:compiler-rt native:backtrace DEPS_green := std rand native:context_switch DEPS_rustuv := std native:uv native:uv_support DEPS_native := std -DEPS_syntax := std term serialize collections +DEPS_syntax := std term serialize collections log DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \ - collections time + collections time log DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \ test time DEPS_flate := std native:miniz DEPS_arena := std collections DEPS_glob := std -DEPS_serialize := std collections +DEPS_serialize := std collections log DEPS_term := std collections DEPS_semver := std DEPS_uuid := std serialize rand @@ -83,6 +83,7 @@ DEPS_time := std serialize DEPS_rand := std DEPS_url := std collections DEPS_workcache := std serialize collections std +DEPS_log := std sync TOOL_DEPS_compiletest := test green rustuv getopts TOOL_DEPS_rustdoc := rustdoc native diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 35e1c242fe28..a1fcddcf6b35 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 f0b9a430771b..7233288a8132 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 9b4d4444da4e..cdb521b96c42 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 94c1131949c6..24478ff8c5fb 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 8733c1271942..2482359c6325 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 69f6ad114316..6aa064bb69a6 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 c697b1c8fd79..78ea407d4eb5 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 7c29a6496f92..97924eca1b9f 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 000000000000..d33ad0c8185a --- /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 or the MIT license +// , 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 { + from_str::(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 { + 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 000000000000..6d2afa2a6431 --- /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 or the MIT license +// , 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 = + 0 as *Vec; + +/// 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, +} + +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) -> 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 = + cast::transmute(DIRECTIVES); + DIRECTIVES = 0 as *Vec; + }); + } +} + +#[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 000000000000..1560eeebfcab --- /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 or the MIT license +// , 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 ff1ff9a569d8..1d7938be2262 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::::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 a054ee66391f..615ed80a6486 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 1b0e08ca6fb9..a8018bec0a6e 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) { }; 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 8510b50777ab..7a42d1bfee36 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 25081017f07d..1c1121f0940c 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 10b209c998bc..91425b89ba66 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 d403efcf8cd2..fb1ee16a9d2a 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 e7764802f170..66749cf5403a 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 156a4f914a90..c2f5d0806a79 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 58bed8a9df99..eda24fb6dc20 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 3f8703b4f756..fff6e4dafb30 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 5b6edeaf79d6..d8b7c5255383 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -61,7 +61,9 @@ pub fn run(input: &str, libs: @RefCell>, 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 cfdd388c0fa1..6cbfeee6aa7a 100644 --- a/src/libsemver/lib.rs +++ b/src/libsemver/lib.rs @@ -170,7 +170,6 @@ fn take_nonempty_prefix>(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 89e1e23637f5..c27c5542ce1e 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 39c7932cdc8f..243f7b2055f3 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 28f6d13070ea..c18d4e273c47 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 a3e5bac89d6d..9eeaf4635a48 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 6bcac4254205..9e988eb4094e 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -398,9 +398,9 @@ pub trait Iterator { /// 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 6b1773ec7ffb..17c0e2235c0b 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 2271a7c23808..000000000000 --- 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 or the MIT license -// , 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, -} - -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.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::); - 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::); - replace(&mut task.get().logger, Some(logger)) -} diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index ece9c1bfd20b..6d96ea94d311 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 b8f00d1b692a..0c46a5012994 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 95eda1cecc09..bf5ba6db5c3e 100644 --- a/src/libstd/ptr.rs +++ b/src/libstd/ptr.rs @@ -163,7 +163,6 @@ pub unsafe fn read_and_zero(dest: *mut T) -> T { SAFETY NOTE: Pointer-arithmetic. Dragons be here. */ pub unsafe fn array_each_with_len(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(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(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 aa024a53b89e..000000000000 --- 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 or the MIT license -// , 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 { - let num = from_str::(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> { - 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 a58826daa494..84e547619df5 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 86e69560e9d8..8c617c1b59b1 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, - 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::); - 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 19f41c6fa1cb..9c88db6beb5f 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, /// The size of the stack for the spawned task stack_size: Option, - /// 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 bab1a00e5ac9..924af6bfd423 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 56a99736866f..f79839339904 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(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 ae8c13a5f987..b575cfaade64 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 { self.mod_path.clone() } + pub fn mod_path(&self) -> Vec { + 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 dc79ceb4daae..c24894af3be4 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 e84d43117e5e..08b4fa7b4445 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 cd52ff4b0ac7..efadea16fe2f 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 ca142ab86976..089c1668bf39 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -156,8 +156,6 @@ impl Terminal { 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 Terminal { 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 Terminal { 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 Terminal { }); 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 e9d71d1c2f7a..8ba3ad53121a 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 4c7226a38801..efd1fbcd1ac5 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 { fn callback(event: &TestEvent, st: &mut ConsoleTestState) -> 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 8b496875c306..eb2b72cb6307 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 98e5c8c2b5bb..7479ddc3e57d 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 79bb5aef764b..e7e0e6d450a7 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 72345022282b..d2c79bbe9cb2 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 4fc7de9f7d2f..10725981a063 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() { 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 aec0bfb1e657..db86be1dfd44 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 bc729acbdf58..be081afc39e8 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, responses: &Sender) { 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, responses: &Sender) { } } 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 a24e830a9874..518b2d4c9ef1 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -35,7 +35,7 @@ fn server(requests: &Receiver, responses: &Sender) { 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, responses: &Sender) { } } 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 6b91d1d534b6..6bf25f2149ce 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 2d52f125747e..90d7da65e1f8 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 318bd16a8b22..78cd5f4c30a3 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 839ffe99e164..7f2cd368219d 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, ch: &Sender) { 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 d4f9d0572b0f..e0938a8ae031 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) { 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 ff70dac2dde8..c3c255b2dc8a 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::(); 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 963a674b5b1d..da4b0677f8f3 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 5b6f6ce73a89..f183975ffe07 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 56f0710dc3ba..475052b637ea 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 65750eb926b4..664db071f828 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 e11b47a1b582..77f47a028d69 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 f300bd51b24e..4a392960a653 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 3102a1a9d994..098c5aaec545 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 1741210f9ed5..8ccf2a9e6758 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 08ced2b002da..92643eca3c83 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 3d1cca46085d..a60348c4a3a6 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 a1803a621a53..87904399e032 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 34a9c0b8fc26..ba011d289255 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 2aa3379993b7..6858b7200db6 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 7143ce0252b7..34b83af1d2ec 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 d07c3feb1942..98d81db82611 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 1bd40ce24bcd..cc0ed2141032 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 134390d0b592..0f07cab3acc1 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 dec248a3015d..64afb4861c34 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 fc865e271e39..a37717ed5d99 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 646ec6928630..4fccb5c3bca2 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 accb90769743..de18759e30a4 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 d49e79d2c64c..aa7ce4fa3478 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 8dc590b47f0c..a35b36fd78ca 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 55fb8222634c..dabe0a594299 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 f6bb2f542837..c44e2bee0520 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 18fd41110183..0fa2ee5be17b 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 67b83ee84e40..e1e0bb4ceca8 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 cab2a5565f4e..738652dddb32 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 f878afce9691..270eeca4c4b6 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 a6ce736c89be..a64216df6c7f 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 e5d4b6ef48cd..8cdf1da5c934 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 18f6fc25149b..5d8932c6e6fa 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 c27c27b5942e..b9e7004bd7ca 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 7e928e190a32..ac893277749e 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 70e76b9fde11..c09938b2f7dd 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 945c3d629527..af543b8d7823 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 0432920c1a6f..b716a7dd023f 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 23b9f0482424..9b82ead04285 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 22762eb4a7eb..6104c02c90a0 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 dcda6afa6ca1..38cae6323203 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 124d4631601d..973e36e494ca 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 ae5a0f04e2c0..3f5127a55b8b 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 5177dc4e4757..7f3319e6d90e 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 e67a79130b1f..721176e2e886 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 7a7f4f20aea0..bd07433eeb09 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 087842d78c70..af4d0ebe6baf 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 e2ca7641500c..3daced7a5ac1 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 ed2e75c4fa60..80e0d037f7c5 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 7896d91443da..bb24192445e8 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 790a5fac1830..4106a7752484 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 691bd3b4211c..684318bafc68 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 bb220091a131..85989c4a40a6 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 db07d9a94e84..cdfc99067765 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 94ca74d2b6a7..f9fb2daaf58a 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 eeb07c71e9bd..24a02821ee2a 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 9d46202d64e2..676d5212e998 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 6ba7d57ef88e..a64d7578af31 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 ad0cdc5451fb..8aa85c03ad4a 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 83b8d79756ff..eccb3784325d 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 7bc277c2eac1..8747d055ff94 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(ch: _chan, data: T) { - info!("{:?}", ch); - info!("{:?}", data); + println!("{:?}", ch); + println!("{:?}", data); fail!(); } @@ -20,7 +20,7 @@ struct _chan(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 8155a2fbda3e..3e1c9e850fa9 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 8df156d8332f..02e1f82e709e 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 b387d3a1719e..5fed317fb09e 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 9e564e997e67..68077d61c9f8 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 e57ac5726fbb..778f3a3b9978 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 5c7a85a03237..c0749984cc9e 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 1c4316672f3f..0b5c6ac4fb3e 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 991a4ed9e090..c74d80df5dc2 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 58c5aabba126..b9a8a53469d5 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 94614e4970a6..22cc9fd28316 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::(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 9c9b4a9f4d5b..6479a9404e2d 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 ce89b66cd5b9..fb2dbacef84e 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 af460dbdd786..68920065d196 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 0c335b9d5575..068ecb7118fc 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 469421751df2..c20764e0728d 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 bf62247e7e78..da9e24b73143 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 c604e66507e0..a77d1b06f176 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 dc3895d0190c..be3f5ba7da86 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 d97c32a64a47..19052d923e9f 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 3545392d5d9f..d93fe4f48d00 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 ef2a4e5335f4..96918cfc6f7d 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 ef2a4e5335f4..96918cfc6f7d 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 0541dcca64d4..daec43ea9935 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 c95d128c0856..e262d088ba01 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 932b9a0d4510..152f90f97407 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::(); - error!("ov1 base = 0x{:x}", base); - error!("ov1 idx = 0x{:x}", idx); - error!("ov1 sizeof::() = 0x{:x}", mem::size_of::()); - error!("ov1 idx * sizeof::() = 0x{:x}", + println!("ov1 base = 0x{:x}", base); + println!("ov1 idx = 0x{:x}", idx); + println!("ov1 sizeof::() = 0x{:x}", mem::size_of::()); + println!("ov1 idx * sizeof::() = 0x{:x}", idx * mem::size_of::()); // 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 06369ba805de..93f55261574e 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 705b7f4028c2..e23145ec2535 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 d9e64fecfd49..b5f39e73fcb1 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 97c4279b1883..583a5c2010a3 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 0d1aebc82e90..a4a6739bfc1d 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 a41ab53964be..06cba673b34c 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::(~"kitty").unwrap()); + println!("{:?}", result::Err::(~"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 7bc5c87c866c..98d7d5cf4370 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 d19788d8b5b8..67f9f5a168fb 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 915e9010b3e0..352e0f656447 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 f9383b9964be..04733552969c 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 190d3f17543b..a49760f3c58c 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 6740331d2f04..49bcde75594d 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 410b86d57146..6343b81fd2a8 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 c4747c6089ef..d9f425403eb0 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 e99c050d16a2..045ffea0fcd4 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 4a5cd2701160..957b631abd39 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 15b0a9140cf5..d5bada4a127f 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 9a37af1e1254..1c797d8369f6 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -83,7 +83,7 @@ fn check_pp(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 5683a2b66986..a0233360a7cc 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: A, b: u16) -> ~Invokable: { 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 5cbd0da23cf7..24c63e5affc0 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 0b3492784c87..e834aa5aa099 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 a4b6d33fb798..c2b276aac095 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(x: T, y: U) -> Pair { 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 233509a8cd2a..3e3d9aab84e8 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 61e36d2d720e..d359f488ca5e 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 d59804b23954..1957992e03d1 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 82e563ae41ce..2fb9bb9edfc9 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(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 4aebcd6aa24c..f14d42e17f3f 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 2e149f88478c..deabead4876b 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 10760236e6dc..d90087ebdea7 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 5cdda81c4360..e9248864c02a 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 3050d6fa0113..6f6d8eba9c0c 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 76dfbffc09c0..cd2bfee700aa 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 57365e98f97e..7c8008b1b3fc 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 00e59f5132db..fda6bcc90c99 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 baec382f3ca3..1e003e1cb9eb 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 acc494a5665f..8f3f254dfe97 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 a5ba89271c4e..59050a64f68f 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -17,6 +17,6 @@ fn unbox(b: Box) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box = Box {c: @foo}; - info!("see what's in our box"); + println!("see what's in our box"); assert_eq!(unbox::(bfoo), foo); } diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index ae98695cf750..b1db8ad92233 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 a831cd1da69d..eacdd8f3978f 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 cb77c63d4511..b276c8a8b070 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 e5e1736044c5..ee01849e7e79 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 41717177f75b..4a5770b3c6c2 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 faa2a3501170..bd18acedbff4 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 97b3eda5eff6..f4c95c5b232e 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 fa498e90503e..c4dc0ac7412f 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 746342ae9734..a9a11361f9b0 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 10b0ac375a95..cdf235b113ee 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 56b61dc5691d..b57851ea3cfb 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 b9288a67f969..e70341612df2 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 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; } } @@ -107,7 +107,7 @@ impl cat { impl cat { 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 caa4a3b2feb6..1b4a9fbd099f 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 dbd34f35e274..d967310b907c 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 55fa783391ad..a93f7c9d73b3 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 f65bf329823c..26708e8f8a23 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 6ba665e4005f..ea75ae2fc5c5 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: A, b: u16) -> ~Invokable: { 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 ad6c92c4925f..ae21d53b7e01 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) { 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 8ce7cb140423..cad7f05171ad 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 562629053cb3..8a2a00f56385 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 a934a0f66884..324f1aade04a 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 fe060ff482e7..8f78d54c7013 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 da5c692d2126..23c143445abe 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 914805c126f3..6bac1511d559 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 f579e7a3d20a..2d33ac4e5dea 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 a0af5e5a9e00..aaa3e3529d41 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 13b21fbe1afe..0b9b8fbcfd33 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 85e5534fcf52..a0d97383f0a3 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 f081d13a5b0b..eaead09a2f7a 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(expected: @T, eq: compare) { fn test_box() { fn compare_box(b1: @bool, b2: @bool) -> bool { - info!("{}", *b1); - info!("{}", *b2); + println!("{}", *b1); + println!("{}", *b2); return *b1 == *b2; } test_generic::(@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 43ddfe6d58f3..b3fbd8c76580 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(expected: ~T, eq: compare) { fn test_box() { fn compare_box(b1: ~bool, b2: ~bool) -> bool { - info!("{}", *b1); - info!("{}", *b2); + println!("{}", *b1); + println!("{}", *b2); return *b1 == *b2; } test_generic::(~true, compare_box); diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs index e3b727fafd3c..67f2d750cc02 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 500ae8951ec4..701ae33132dc 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 c49d589572cb..16142b2f8967 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 c35e84154d80..c67810bb17a8 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 ccd79600a15a..43c7887d3ef6 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 d7b8ed583a51..ba4f0ccfe648 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 2f79784ce540..172ec2f09050 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 973da6eab8d6..e29cad9c2a3f 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 26974bbcecef..08daf1bd80e4 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 987ee233810f..277f0011c1cf 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 e01c7ee998c3..455b71aff877 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 7011088fa5d4..7a728e18a290 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 81e9ac1b8087..bb726773bb5d 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 72427b6c5390..9e7344a8dfc0 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 { 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 a54c68a907b9..898d0c0ec231 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: 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 396ac88bd06d..80f64d8df3d8 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: T) -> Pair { pub fn main() { let b = f::(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 6eccdb93d8c8..9ee237e97f0e 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(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 64e7d0101b87..c27aff53b679 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(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 27dc4ad8069b..13a9d57e578d 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::(x); - info!("{}", y); + println!("{}", y); assert_eq!(x, y); b = id::(a); - info!("{}", b); + println!("{}", b); assert_eq!(a, b); q = id::(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 f740d8cb2d15..c20de257315f 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 { arm(T), } fn altfoo(f: foo) { let mut hit = false; - match f { arm::(_x) => { info!("in arm"); hit = true; } } + match f { arm::(_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 7c4139664afa..e98489601809 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 = some::(5); - match nop { some::(n) => { info!("{:?}", n); assert!((n == 5)); } } + match nop { some::(n) => { println!("{:?}", n); assert!((n == 5)); } } let nop2: noption = 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 f2dbc5a0d319..99be8a5478c2 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(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 9626884be9dd..2e9bd371e29c 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 { 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 fe27eca77303..20d33a09f79e 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 6ac169fed9b0..97429131a7c3 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 50a1b4345dc7..22b5281ef38f 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 2d9390245272..dc5c7d11769b 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 176a7ba00473..5765df4dafad 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 756fa7d45630..7a3c6a138779 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 261283991059..651f86e58980 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 73b3f4e34830..ff858e81bb8d 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 157ae16c5e7d..f41e4d7d373f 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 ed5ac89145c3..cf8dfd5469c9 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 63b6cd3b42fe..fadbc5345190 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 e3d9a68afccb..69706a324b63 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 6dbc80c6a459..95a10df5f812 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 edc71b524e33..18ff6fe18963 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 14115fa52daa..3f2c3f4fbd7a 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 2dbed23677f7..48a1fd3f7832 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 4a1bb2ea8776..311ce2d64b20 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 bde18d77b9ad..a9ebfbcbf332 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 7c2c1eab87bb..2e294c30a3f7 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 5e6ea5f6d44e..fccd9f3da0b9 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 8370e0f7f9c8..ca48f3ffd50d 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 463ed02a716b..0fa93f37840a 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 8cf9436ef513..aeef29acd0ea 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 15580a01f7ad..dc22ebce804e 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 d50a1b6a0be6..424f4648d8e5 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) { 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 0e51da7dae17..8722376ab59e 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 05404b16f16a..99d943a2f6bd 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 ddac18235469..f51221c419ef 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 11d392f1fb1b..538699512a3a 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 9b3db58ea9b2..b8d56f761b8d 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 c44b7389666f..794c4f4016e6 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 59baf63d2840..a664daeb7f8c 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 c34e65b2b421..f0149c811f0d 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 a3dc848344c4..aa303aa3b817 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 d58e7f2a2873..60f7689ecfa6 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 67bbd0967206..2e788737e4d7 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 3e11f74f04ab..0dba1830cbd2 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 57aeac9fcf87..01eabad1596a 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 c5221cd73d7e..b4a673284811 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 c5ff2bc46cd9..b3a77aa96752 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 ba85db6f38bd..587e0b9d4c5f 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 4913df823b4d..d582b7706023 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 d6f148f559db..b9b16d10b8c3 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 2a368568f8ca..fe1ef4817c6a 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 861d72ea228a..7e55e227cc07 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::(3) { None:: => { fail!() } Some::(_) => { 5 } }; - info!("{}", i); + println!("{}", i); } diff --git a/src/test/run-pass/match-join.rs b/src/test/run-pass/match-join.rs index d6654db854f8..47b2ddd5022d 100644 --- a/src/test/run-pass/match-join.rs +++ b/src/test/run-pass/match-join.rs @@ -25,4 +25,4 @@ fn foo(y: Option) { return; } -pub fn main() { info!("hello"); foo::(Some::(5)); } +pub fn main() { println!("hello"); foo::(Some::(5)); } diff --git a/src/test/run-pass/match-pattern-drop.rs b/src/test/run-pass/match-pattern-drop.rs index e0735e7ad24d..e00ee1182954 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 84e9012be4e2..9d59b197d3ab 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 2076f46e8ab7..e5be0e52b949 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 { nothing, just(T), } fn foo(x: maybe) { 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 50aa840e6d74..9fc3a7acf717 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 4257442ea33c..2109f7ef1eaf 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 34ce5c66539d..e01128554c72 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 a516e2bf9bc0..5f86cde261c5 100644 --- a/src/test/run-pass/nested-matchs.rs +++ b/src/test/run-pass/nested-matchs.rs @@ -16,9 +16,9 @@ fn foo() { Some::(_x) => { let mut bar; match None:: { None:: => { bar = 5; } _ => { baz(); } } - info!("{:?}", bar); + println!("{:?}", bar); } - None:: => { info!("hello"); } + None:: => { println!("hello"); } } } diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs index 0bc6280393cf..bc03b0d27ca8 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), } fn nested(o: t) { match o { - bar(_i, Some::(_)) => { error!("wrong pattern matched"); fail!(); } - _ => { error!("succeeded"); } + bar(_i, Some::(_)) => { println!("wrong pattern matched"); fail!(); } + _ => { println!("succeeded"); } } } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index 1fda2c806088..3f00cf7d1840 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 cbd0416cb69b..9a2e83ef2d07 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 751ba78b2820..d9669812d2ad 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 087c04e0ff01..45f19a30e86a 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 0f7e33ce340b..fed766b23d96 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 df1d22f2c86f..53d2a47863b9 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) { - 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) { 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 bbb312842ce1..3bceefb83185 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 8c1be0a62197..26e6f568ce20 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 050a51c958d5..b958588622fb 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 86745deaad8b..49e0faf46932 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::()); - info!("size outer = {:?}", mem::size_of::()); - info!("y = {}", y); + println!("align inner = {:?}", rusti::min_align_of::()); + println!("size outer = {:?}", mem::size_of::()); + println!("y = {}", y); // per clang/gcc the alignment of `inner` is 4 on x86. assert_eq!(rusti::min_align_of::(), m::align()); diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 560425dcb21b..16d1a0c464c7 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::()); - info!("size outer = {}", mem::size_of::()); - info!("y = {}", y); + println!("align inner = {}", rusti::min_align_of::()); + println!("size outer = {}", mem::size_of::()); + println!("y = {}", y); // per clang/gcc the alignment of `Inner` is 4 on x86. assert_eq!(rusti::min_align_of::(), m::m::align()); diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs index 57da2e038325..a1d57241e070 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 f81ddabf77c7..6f91497a81c9 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 898759f67d24..357d829627da 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 5b1b1dd8ec3b..994140ee1445 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 cc8174d0d320..f1e6c6a0e2fe 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 6e2d62cce927..c4037a70d969 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 bb612c5b0df2..62be58605084 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 9d994c423c9a..ff4b43cb6b5f 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 9f2069908437..e091092b653a 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 bec101a6d45a..55d9a8bc63a3 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 93183f8dba47..af0e9572f38d 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) -> 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 4f9e3c2c1f64..468b6ca51a03 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 a39907d5c7ed..835b5990ac2d 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 c5211889f3f0..b277c16dc4a9 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:: { some::(_) => { 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 cb8d73108748..b74f080ede73 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 e3d3b3389ba1..04c1af4326bb 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 d8b7c99d000a..c0c1135b6d52 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 { none, } pub fn main() { let x = none::; - match x { none:: => { info!("hello world"); } } + match x { none:: => { println!("hello world"); } } } diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs index 2caef2d1b9e1..5731b8de5294 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 { a(T, int), b, } fn uhoh(v: ~[clam]) { match v[1] { a::(ref _t, ref u) => { - info!("incorrect"); - info!("{:?}", u); + println!("incorrect"); + println!("{:?}", u); fail!(); } - b:: => { info!("correct"); } + b:: => { println!("correct"); } } } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index 8c9de64687e2..fe4e38ee879b 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 987aa9ee7e32..741e20d42db8 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 8530c583b165..6bac7f2a06e7 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 714dddf4ab6d..db8dc0f64c47 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 90d5bae56f43..ad6e668524cb 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 8b87682384b6..627bb54dad39 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 ebed8e24a484..37abb4be87f2 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 10230065b914..f2fa8a06bfd8 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 c5f8d0410d81..0657f1a8faec 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 c668981b40a7..f9a5de40f494 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 60e5a157bfc4..e3f2456c4c44 100644 --- a/src/test/run-pass/supported-cast.rs +++ b/src/test/run-pass/supported-cast.rs @@ -12,221 +12,221 @@ use std::libc; pub fn main() { let f = 1 as *libc::FILE; - info!("{}", f as int); - info!("{}", f as uint); - info!("{}", f as i8); - info!("{}", f as i16); - info!("{}", f as i32); - info!("{}", f as i64); - info!("{}", f as u8); - info!("{}", f as u16); - info!("{}", f as u32); - info!("{}", f as u64); + println!("{}", f as int); + println!("{}", f as uint); + println!("{}", f as i8); + println!("{}", f as i16); + println!("{}", f as i32); + println!("{}", f as i64); + println!("{}", f as u8); + println!("{}", f as u16); + println!("{}", f as u32); + println!("{}", f as u64); - info!("{}", 1 as int); - info!("{}", 1 as uint); - info!("{}", 1 as *libc::FILE); - info!("{}", 1 as i8); - info!("{}", 1 as i16); - info!("{}", 1 as i32); - info!("{}", 1 as i64); - info!("{}", 1 as u8); - info!("{}", 1 as u16); - info!("{}", 1 as u32); - info!("{}", 1 as u64); - info!("{}", 1 as f32); - info!("{}", 1 as f64); + println!("{}", 1 as int); + println!("{}", 1 as uint); + println!("{}", 1 as *libc::FILE); + println!("{}", 1 as i8); + println!("{}", 1 as i16); + println!("{}", 1 as i32); + println!("{}", 1 as i64); + println!("{}", 1 as u8); + println!("{}", 1 as u16); + println!("{}", 1 as u32); + println!("{}", 1 as u64); + println!("{}", 1 as f32); + println!("{}", 1 as f64); - info!("{}", 1u as int); - info!("{}", 1u as uint); - info!("{}", 1u as *libc::FILE); - info!("{}", 1u as i8); - info!("{}", 1u as i16); - info!("{}", 1u as i32); - info!("{}", 1u as i64); - info!("{}", 1u as u8); - info!("{}", 1u as u16); - info!("{}", 1u as u32); - info!("{}", 1u as u64); - info!("{}", 1u as f32); - info!("{}", 1u as f64); + println!("{}", 1u as int); + println!("{}", 1u as uint); + println!("{}", 1u as *libc::FILE); + println!("{}", 1u as i8); + println!("{}", 1u as i16); + println!("{}", 1u as i32); + println!("{}", 1u as i64); + println!("{}", 1u as u8); + println!("{}", 1u as u16); + println!("{}", 1u as u32); + println!("{}", 1u as u64); + println!("{}", 1u as f32); + println!("{}", 1u as f64); - info!("{}", 1i8 as int); - info!("{}", 1i8 as uint); - info!("{}", 1i8 as *libc::FILE); - info!("{}", 1i8 as i8); - info!("{}", 1i8 as i16); - info!("{}", 1i8 as i32); - info!("{}", 1i8 as i64); - info!("{}", 1i8 as u8); - info!("{}", 1i8 as u16); - info!("{}", 1i8 as u32); - info!("{}", 1i8 as u64); - info!("{}", 1i8 as f32); - info!("{}", 1i8 as f64); + println!("{}", 1i8 as int); + println!("{}", 1i8 as uint); + println!("{}", 1i8 as *libc::FILE); + println!("{}", 1i8 as i8); + println!("{}", 1i8 as i16); + println!("{}", 1i8 as i32); + println!("{}", 1i8 as i64); + println!("{}", 1i8 as u8); + println!("{}", 1i8 as u16); + println!("{}", 1i8 as u32); + println!("{}", 1i8 as u64); + println!("{}", 1i8 as f32); + println!("{}", 1i8 as f64); - info!("{}", 1u8 as int); - info!("{}", 1u8 as uint); - info!("{}", 1u8 as *libc::FILE); - info!("{}", 1u8 as i8); - info!("{}", 1u8 as i16); - info!("{}", 1u8 as i32); - info!("{}", 1u8 as i64); - info!("{}", 1u8 as u8); - info!("{}", 1u8 as u16); - info!("{}", 1u8 as u32); - info!("{}", 1u8 as u64); - info!("{}", 1u8 as f32); - info!("{}", 1u8 as f64); + println!("{}", 1u8 as int); + println!("{}", 1u8 as uint); + println!("{}", 1u8 as *libc::FILE); + println!("{}", 1u8 as i8); + println!("{}", 1u8 as i16); + println!("{}", 1u8 as i32); + println!("{}", 1u8 as i64); + println!("{}", 1u8 as u8); + println!("{}", 1u8 as u16); + println!("{}", 1u8 as u32); + println!("{}", 1u8 as u64); + println!("{}", 1u8 as f32); + println!("{}", 1u8 as f64); - info!("{}", 1i16 as int); - info!("{}", 1i16 as uint); - info!("{}", 1i16 as *libc::FILE); - info!("{}", 1i16 as i8); - info!("{}", 1i16 as i16); - info!("{}", 1i16 as i32); - info!("{}", 1i16 as i64); - info!("{}", 1i16 as u8); - info!("{}", 1i16 as u16); - info!("{}", 1i16 as u32); - info!("{}", 1i16 as u64); - info!("{}", 1i16 as f32); - info!("{}", 1i16 as f64); + println!("{}", 1i16 as int); + println!("{}", 1i16 as uint); + println!("{}", 1i16 as *libc::FILE); + println!("{}", 1i16 as i8); + println!("{}", 1i16 as i16); + println!("{}", 1i16 as i32); + println!("{}", 1i16 as i64); + println!("{}", 1i16 as u8); + println!("{}", 1i16 as u16); + println!("{}", 1i16 as u32); + println!("{}", 1i16 as u64); + println!("{}", 1i16 as f32); + println!("{}", 1i16 as f64); - info!("{}", 1u16 as int); - info!("{}", 1u16 as uint); - info!("{}", 1u16 as *libc::FILE); - info!("{}", 1u16 as i8); - info!("{}", 1u16 as i16); - info!("{}", 1u16 as i32); - info!("{}", 1u16 as i64); - info!("{}", 1u16 as u8); - info!("{}", 1u16 as u16); - info!("{}", 1u16 as u32); - info!("{}", 1u16 as u64); - info!("{}", 1u16 as f32); - info!("{}", 1u16 as f64); + println!("{}", 1u16 as int); + println!("{}", 1u16 as uint); + println!("{}", 1u16 as *libc::FILE); + println!("{}", 1u16 as i8); + println!("{}", 1u16 as i16); + println!("{}", 1u16 as i32); + println!("{}", 1u16 as i64); + println!("{}", 1u16 as u8); + println!("{}", 1u16 as u16); + println!("{}", 1u16 as u32); + println!("{}", 1u16 as u64); + println!("{}", 1u16 as f32); + println!("{}", 1u16 as f64); - info!("{}", 1i32 as int); - info!("{}", 1i32 as uint); - info!("{}", 1i32 as *libc::FILE); - info!("{}", 1i32 as i8); - info!("{}", 1i32 as i16); - info!("{}", 1i32 as i32); - info!("{}", 1i32 as i64); - info!("{}", 1i32 as u8); - info!("{}", 1i32 as u16); - info!("{}", 1i32 as u32); - info!("{}", 1i32 as u64); - info!("{}", 1i32 as f32); - info!("{}", 1i32 as f64); + println!("{}", 1i32 as int); + println!("{}", 1i32 as uint); + println!("{}", 1i32 as *libc::FILE); + println!("{}", 1i32 as i8); + println!("{}", 1i32 as i16); + println!("{}", 1i32 as i32); + println!("{}", 1i32 as i64); + println!("{}", 1i32 as u8); + println!("{}", 1i32 as u16); + println!("{}", 1i32 as u32); + println!("{}", 1i32 as u64); + println!("{}", 1i32 as f32); + println!("{}", 1i32 as f64); - info!("{}", 1u32 as int); - info!("{}", 1u32 as uint); - info!("{}", 1u32 as *libc::FILE); - info!("{}", 1u32 as i8); - info!("{}", 1u32 as i16); - info!("{}", 1u32 as i32); - info!("{}", 1u32 as i64); - info!("{}", 1u32 as u8); - info!("{}", 1u32 as u16); - info!("{}", 1u32 as u32); - info!("{}", 1u32 as u64); - info!("{}", 1u32 as f32); - info!("{}", 1u32 as f64); + println!("{}", 1u32 as int); + println!("{}", 1u32 as uint); + println!("{}", 1u32 as *libc::FILE); + println!("{}", 1u32 as i8); + println!("{}", 1u32 as i16); + println!("{}", 1u32 as i32); + println!("{}", 1u32 as i64); + println!("{}", 1u32 as u8); + println!("{}", 1u32 as u16); + println!("{}", 1u32 as u32); + println!("{}", 1u32 as u64); + println!("{}", 1u32 as f32); + println!("{}", 1u32 as f64); - info!("{}", 1i64 as int); - info!("{}", 1i64 as uint); - info!("{}", 1i64 as *libc::FILE); - info!("{}", 1i64 as i8); - info!("{}", 1i64 as i16); - info!("{}", 1i64 as i32); - info!("{}", 1i64 as i64); - info!("{}", 1i64 as u8); - info!("{}", 1i64 as u16); - info!("{}", 1i64 as u32); - info!("{}", 1i64 as u64); - info!("{}", 1i64 as f32); - info!("{}", 1i64 as f64); + println!("{}", 1i64 as int); + println!("{}", 1i64 as uint); + println!("{}", 1i64 as *libc::FILE); + println!("{}", 1i64 as i8); + println!("{}", 1i64 as i16); + println!("{}", 1i64 as i32); + println!("{}", 1i64 as i64); + println!("{}", 1i64 as u8); + println!("{}", 1i64 as u16); + println!("{}", 1i64 as u32); + println!("{}", 1i64 as u64); + println!("{}", 1i64 as f32); + println!("{}", 1i64 as f64); - info!("{}", 1u64 as int); - info!("{}", 1u64 as uint); - info!("{}", 1u64 as *libc::FILE); - info!("{}", 1u64 as i8); - info!("{}", 1u64 as i16); - info!("{}", 1u64 as i32); - info!("{}", 1u64 as i64); - info!("{}", 1u64 as u8); - info!("{}", 1u64 as u16); - info!("{}", 1u64 as u32); - info!("{}", 1u64 as u64); - info!("{}", 1u64 as f32); - info!("{}", 1u64 as f64); + println!("{}", 1u64 as int); + println!("{}", 1u64 as uint); + println!("{}", 1u64 as *libc::FILE); + println!("{}", 1u64 as i8); + println!("{}", 1u64 as i16); + println!("{}", 1u64 as i32); + println!("{}", 1u64 as i64); + println!("{}", 1u64 as u8); + println!("{}", 1u64 as u16); + println!("{}", 1u64 as u32); + println!("{}", 1u64 as u64); + println!("{}", 1u64 as f32); + println!("{}", 1u64 as f64); - info!("{}", 1u64 as int); - info!("{}", 1u64 as uint); - info!("{}", 1u64 as *libc::FILE); - info!("{}", 1u64 as i8); - info!("{}", 1u64 as i16); - info!("{}", 1u64 as i32); - info!("{}", 1u64 as i64); - info!("{}", 1u64 as u8); - info!("{}", 1u64 as u16); - info!("{}", 1u64 as u32); - info!("{}", 1u64 as u64); - info!("{}", 1u64 as f32); - info!("{}", 1u64 as f64); + println!("{}", 1u64 as int); + println!("{}", 1u64 as uint); + println!("{}", 1u64 as *libc::FILE); + println!("{}", 1u64 as i8); + println!("{}", 1u64 as i16); + println!("{}", 1u64 as i32); + println!("{}", 1u64 as i64); + println!("{}", 1u64 as u8); + println!("{}", 1u64 as u16); + println!("{}", 1u64 as u32); + println!("{}", 1u64 as u64); + println!("{}", 1u64 as f32); + println!("{}", 1u64 as f64); - info!("{}", true as int); - info!("{}", true as uint); - info!("{}", true as *libc::FILE); - info!("{}", true as i8); - info!("{}", true as i16); - info!("{}", true as i32); - info!("{}", true as i64); - info!("{}", true as u8); - info!("{}", true as u16); - info!("{}", true as u32); - info!("{}", true as u64); - info!("{}", true as f32); - info!("{}", true as f64); + println!("{}", true as int); + println!("{}", true as uint); + println!("{}", true as *libc::FILE); + println!("{}", true as i8); + println!("{}", true as i16); + println!("{}", true as i32); + println!("{}", true as i64); + println!("{}", true as u8); + println!("{}", true as u16); + println!("{}", true as u32); + println!("{}", true as u64); + println!("{}", true as f32); + println!("{}", true as f64); - info!("{}", 1. as int); - info!("{}", 1. as uint); - info!("{}", 1. as i8); - info!("{}", 1. as i16); - info!("{}", 1. as i32); - info!("{}", 1. as i64); - info!("{}", 1. as u8); - info!("{}", 1. as u16); - info!("{}", 1. as u32); - info!("{}", 1. as u64); - info!("{}", 1. as f32); - info!("{}", 1. as f64); + println!("{}", 1. as int); + println!("{}", 1. as uint); + println!("{}", 1. as i8); + println!("{}", 1. as i16); + println!("{}", 1. as i32); + println!("{}", 1. as i64); + println!("{}", 1. as u8); + println!("{}", 1. as u16); + println!("{}", 1. as u32); + println!("{}", 1. as u64); + println!("{}", 1. as f32); + println!("{}", 1. as f64); - info!("{}", 1f32 as int); - info!("{}", 1f32 as uint); - info!("{}", 1f32 as i8); - info!("{}", 1f32 as i16); - info!("{}", 1f32 as i32); - info!("{}", 1f32 as i64); - info!("{}", 1f32 as u8); - info!("{}", 1f32 as u16); - info!("{}", 1f32 as u32); - info!("{}", 1f32 as u64); - info!("{}", 1f32 as f32); - info!("{}", 1f32 as f64); + println!("{}", 1f32 as int); + println!("{}", 1f32 as uint); + println!("{}", 1f32 as i8); + println!("{}", 1f32 as i16); + println!("{}", 1f32 as i32); + println!("{}", 1f32 as i64); + println!("{}", 1f32 as u8); + println!("{}", 1f32 as u16); + println!("{}", 1f32 as u32); + println!("{}", 1f32 as u64); + println!("{}", 1f32 as f32); + println!("{}", 1f32 as f64); - info!("{}", 1f64 as int); - info!("{}", 1f64 as uint); - info!("{}", 1f64 as i8); - info!("{}", 1f64 as i16); - info!("{}", 1f64 as i32); - info!("{}", 1f64 as i64); - info!("{}", 1f64 as u8); - info!("{}", 1f64 as u16); - info!("{}", 1f64 as u32); - info!("{}", 1f64 as u64); - info!("{}", 1f64 as f32); - info!("{}", 1f64 as f64); + println!("{}", 1f64 as int); + println!("{}", 1f64 as uint); + println!("{}", 1f64 as i8); + println!("{}", 1f64 as i16); + println!("{}", 1f64 as i32); + println!("{}", 1f64 as i64); + println!("{}", 1f64 as u8); + println!("{}", 1f64 as u16); + println!("{}", 1f64 as u32); + println!("{}", 1f64 as u64); + println!("{}", 1f64 as f32); + println!("{}", 1f64 as f64); } diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index 78cc48e4ed4b..781a50b87a7d 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 05b3f98ea08c..5cf6c2af12b8 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 cbab11003b17..55235974e130 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) { 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 830aecfa86cc..8eaa7f2e31d9 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 844e39e584ed..6299cfdee202 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>) { 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 d0c5efbfa227..275c99f99a95 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 0b1e9580a1e2..6d06578c6cd1 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, 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 799ee6093008..9559e5c84afb 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) { - 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 0ed76593b9e8..176b64e41d00 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, 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 411730dac785..6418921172a3 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 f2493e5d1022..a4e6be4f2d52 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 2bb839aa2cfe..873269190c52 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 b00689db26b8..dc862f201c24 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 a9e2979f7dbc..840ab18dafa3 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 a0c2a489bf64..11d1b9ecbfe3 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 50af6cb71c1f..ed72a758c78b 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 4898ef1cd0ae..adbbf1aec9af 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 48a49996aeeb..7bb0fe5faa18 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 b1fc4e76ea08..c5d55ff0386e 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 96d61b377af5..06f73777032d 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 077bbdfb0baa..7f11e7b7df5c 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 fc37e1c39ed0..2d05eb221967 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) -> complainer { - error!("Hello!"); + println!("Hello!"); complainer { tx: tx } @@ -39,6 +39,6 @@ fn f(tx: Sender) { 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 69e28e30d092..a5659a4648e0 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(o: myoption) -> int { enum myoption { 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 a85861d2aa5d..9bf98baa303b 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(o: myoption) -> int { enum myoption { 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 1520a8b7e611..9531563fcbef 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 7014ad5df141..9b42a25956ee 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 7ffbade05c1c..c15a7fcdf29d 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 f190fd2cb936..cd20917a1790 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 10726a9c396b..0e4f4194a549 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 ed7ba12ea0f2..3e1a232115f7 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 a21aa4a9a624..8ef98901e9f0 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 57bc3bda9636..1f16b5fdb5c6 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 fe2506ad686a..bd8b1f0f088a 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 01370ed12b44..b2cf771faee3 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 4ec30d6e02a0..bd44bdd51cd8 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 c08c62b47a22..14ba368bdfad 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 7bc3c1fc1f4d..c6cb0dd65e77 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(); } }