From cc6ec8df95fbd8163b7c2c6c34469fb96b704e66 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 8 Mar 2014 22:11:44 -0800 Subject: [PATCH 1/5] 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 | 434 +++++++++--------- 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, 1577 insertions(+), 1571 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 2a6e38a6d3d46..7c12b4edacb5b 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 35e1c242fe289..a1fcddcf6b351 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 f0b9a430771b5..7233288a81328 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 9b4d4444da4ea..cdb521b96c42f 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 94c1131949c63..24478ff8c5fb5 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 8733c12719429..2482359c6325a 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 69f6ad1143168..6aa064bb69a6a 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 c697b1c8fd79f..78ea407d4eb53 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 7c29a6496f92d..97924eca1b9fc 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 0000000000000..d33ad0c8185ac --- /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 0000000000000..6d2afa2a64310 --- /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 0000000000000..1560eeebfcab2 --- /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 ff1ff9a569d85..1d7938be22620 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 a054ee66391fa..615ed80a64866 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 1b0e08ca6fb97..a8018bec0a6e3 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 8510b50777abd..7a42d1bfee368 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 25081017f07d5..1c1121f0940ce 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 10b209c998bc1..91425b89ba669 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 d403efcf8cd26..fb1ee16a9d2a4 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 e7764802f1707..66749cf5403a3 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 156a4f914a909..c2f5d0806a798 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 58bed8a9df993..eda24fb6dc20a 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 3f8703b4f7563..fff6e4dafb303 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 5b6edeaf79d68..d8b7c52553836 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 cfdd388c0fa12..6cbfeee6aa7ad 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 89e1e23637f5f..c27c5542ce1e0 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 39c7932cdc8f2..243f7b2055f39 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 28f6d13070eae..c18d4e273c477 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 a3e5bac89d6de..9eeaf4635a482 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 6bcac42542051..9e988eb4094ee 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 6b1773ec7ffbe..17c0e2235c0bf 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 2271a7c23808f..0000000000000 --- 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 ece9c1bfd20bd..6d96ea94d3115 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 b8f00d1b692a8..0c46a5012994a 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 95eda1cecc09e..bf5ba6db5c3ef 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 aa024a53b89ec..0000000000000 --- 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 a58826daa494e..84e547619df5a 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 86e69560e9d8b..8c617c1b59b18 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 19f41c6fa1cb1..9c88db6beb5f8 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 bab1a00e5ac9d..924af6bfd423c 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 56a99736866f6..f798393399045 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 ae8c13a5f9870..b575cfaade644 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 dc79ceb4daae2..c24894af3be46 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 e84d43117e5ef..08b4fa7b44450 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 cd52ff4b0ac71..efadea16fe2f2 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 ca142ab869769..089c1668bf39b 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 e9d71d1c2f7a3..8ba3ad53121ae 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 4c7226a388013..efd1fbcd1ac51 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 8b496875c306a..eb2b72cb63072 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 98e5c8c2b5bbd..7479ddc3e57d3 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 79bb5aef764b3..e7e0e6d450a7e 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 72345022282bf..d2c79bbe9cb2d 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 4fc7de9f7d2f5..10725981a063d 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 aec0bfb1e657c..db86be1dfd442 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 bc729acbdf58b..be081afc39e80 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 a24e830a98748..518b2d4c9ef1d 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 6b91d1d534b62..6bf25f2149ce8 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 2d52f125747e8..90d7da65e1f8f 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 318bd16a8b221..78cd5f4c30a36 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 839ffe99e1649..7f2cd368219d3 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 d4f9d0572b0fe..e0938a8ae0310 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 ff70dac2dde8c..c3c255b2dc8ab 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 963a674b5b1dd..da4b0677f8f35 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 5b6f6ce73a89a..f183975ffe078 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 56f0710dc3ba6..475052b637eab 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 65750eb926b45..664db071f828d 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 e11b47a1b582c..77f47a028d698 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 f300bd51b24ec..4a392960a6533 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 3102a1a9d9948..098c5aaec545c 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 1741210f9ed50..8ccf2a9e67585 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 08ced2b002da6..92643eca3c83b 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 3d1cca46085db..a60348c4a3a67 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 a1803a621a53f..87904399e032f 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 34a9c0b8fc26d..ba011d289255f 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 2aa3379993b7a..6858b7200db6c 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 7143ce0252b73..34b83af1d2ece 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 d07c3feb19423..98d81db826114 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 1bd40ce24bcd7..cc0ed21410323 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 134390d0b5927..0f07cab3acc1b 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 dec248a3015d5..64afb4861c34c 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 fc865e271e39c..a37717ed5d998 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 646ec69286304..4fccb5c3bca2a 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 accb907697430..de18759e30a4c 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 d49e79d2c64c3..aa7ce4fa34788 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 8dc590b47f0c6..a35b36fd78ca8 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 55fb8222634cc..dabe0a5942997 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 f6bb2f5428370..c44e2bee0520c 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 18fd411101834..0fa2ee5be17b7 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 67b83ee84e406..e1e0bb4ceca8e 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 cab2a5565f4ec..738652dddb32a 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 f878afce96916..270eeca4c4b6e 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 a6ce736c89be6..a64216df6c7fe 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 e5d4b6ef48cd6..8cdf1da5c934c 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 18f6fc25149bf..5d8932c6e6fa8 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 c27c27b5942e1..b9e7004bd7ca4 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 7e928e190a327..ac893277749e1 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 70e76b9fde11c..c09938b2f7ddf 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 945c3d6295277..af543b8d7823a 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 0432920c1a6fe..b716a7dd023ff 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 23b9f04824247..9b82ead042859 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 22762eb4a7eb5..6104c02c90a03 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 dcda6afa6ca1e..38cae63232034 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 124d4631601d6..973e36e494ca6 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 ae5a0f04e2c04..3f5127a55b8bf 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 5177dc4e47570..7f3319e6d90e6 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 e67a79130b1f9..721176e2e8860 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 7a7f4f20aea07..bd07433eeb095 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 087842d78c709..af4d0ebe6bafa 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 e2ca7641500c3..3daced7a5ac18 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 ed2e75c4fa602..80e0d037f7c51 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 7896d91443dad..bb24192445e84 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 790a5fac18305..4106a77524845 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 691bd3b4211cc..684318bafc685 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 bb220091a1314..85989c4a40a6b 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 db07d9a94e84d..cdfc990677657 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 94ca74d2b6a79..f9fb2daaf58a2 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 eeb07c71e9bd3..24a02821ee2a9 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 9d46202d64e21..676d5212e9980 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 6ba7d57ef88e9..a64d7578af319 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 ad0cdc5451fbe..8aa85c03ad4ad 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 83b8d79756ff7..eccb3784325d9 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 7bc277c2eac1e..8747d055ff945 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 8155a2fbda3e2..3e1c9e850fa9e 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 8df156d8332fe..02e1f82e709e6 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 b387d3a1719e9..5fed317fb09e3 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 9e564e997e673..68077d61c9f81 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 e57ac5726fbba..778f3a3b99784 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 5c7a85a03237c..c0749984cc9e3 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 1c4316672f3fb..0b5c6ac4fb3e2 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 991a4ed9e0900..c74d80df5dc27 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 58c5aabba1267..b9a8a53469d5a 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 94614e4970a62..22cc9fd283163 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 9c9b4a9f4d5b0..6479a9404e2d5 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 ce89b66cd5b94..fb2dbacef84e7 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 af460dbdd7868..68920065d1967 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 0c335b9d5575f..068ecb7118fc2 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 469421751df2b..c20764e0728d1 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 bf62247e7e785..da9e24b731434 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 c604e66507e0a..a77d1b06f176d 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 dc3895d0190cd..be3f5ba7da86d 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 d97c32a64a47c..19052d923e9f2 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 3545392d5d9f7..d93fe4f48d004 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 ef2a4e5335f45..96918cfc6f7d3 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 ef2a4e5335f45..96918cfc6f7d3 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 0541dcca64d4d..daec43ea99352 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 c95d128c08561..e262d088ba018 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 932b9a0d45106..152f90f974079 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 06369ba805de4..93f55261574ea 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 705b7f4028c27..e23145ec25357 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 d9e64fecfd49f..b5f39e73fcb1a 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 97c4279b18837..583a5c2010a37 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 0d1aebc82e903..a4a6739bfc1d4 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 a41ab53964bec..06cba673b34c0 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 7bc5c87c866c0..98d7d5cf43704 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 d19788d8b5b84..67f9f5a168fba 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 915e9010b3e0f..352e0f6564470 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 f9383b9964be0..04733552969c5 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 190d3f17543b4..a49760f3c58cb 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 6740331d2f048..49bcde75594dd 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 410b86d57146b..6343b81fd2a80 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 c4747c6089ef5..d9f425403eb07 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 e99c050d16a20..045ffea0fcd4c 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 4a5cd27011605..957b631abd39a 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 15b0a9140cf51..d5bada4a127f9 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 9a37af1e1254c..1c797d8369f6a 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 5683a2b669861..a0233360a7ccf 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 5cbd0da23cf7f..24c63e5affc0d 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 0b3492784c871..e834aa5aa099d 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 a4b6d33fb7986..c2b276aac095b 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 233509a8cd2a8..3e3d9aab84e89 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 61e36d2d720e7..d359f488ca5ec 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 d59804b23954e..1957992e03d15 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 82e563ae41ced..2fb9bb9edfc91 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 4aebcd6aa24c9..f14d42e17f3f3 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 2e149f88478c1..deabead4876b3 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 10760236e6dc3..d90087ebdea78 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 5cdda81c43604..e9248864c02ad 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 3050d6fa01130..6f6d8eba9c0c4 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 76dfbffc09c06..cd2bfee700aa5 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 57365e98f97e9..7c8008b1b3fc5 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 00e59f5132db7..fda6bcc90c991 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 baec382f3ca3a..1e003e1cb9eb0 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 acc494a5665f4..8f3f254dfe97a 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 a5ba89271c4eb..59050a64f68f9 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 ae98695cf7500..b1db8ad922332 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 a831cd1da69d5..eacdd8f3978f6 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 cb77c63d4511a..b276c8a8b0706 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 e5e1736044c5d..ee01849e7e794 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 41717177f75bc..4a5770b3c6c24 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 faa2a35011704..bd18acedbff4f 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 97b3eda5eff63..f4c95c5b232e0 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 fa498e90503e8..c4dc0ac7412fd 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 746342ae97345..a9a11361f9b0e 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 10b0ac375a95d..cdf235b113ee5 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 56b61dc5691df..b57851ea3cfb9 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 b9288a67f969f..e70341612df2a 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 caa4a3b2feb6f..1b4a9fbd099f5 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 dbd34f35e2740..d967310b907c4 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 55fa783391ad9..a93f7c9d73b3e 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 f65bf329823c2..26708e8f8a235 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 6ba665e4005f5..ea75ae2fc5c55 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 ad6c92c4925fb..ae21d53b7e01d 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 8ce7cb140423d..cad7f05171ad0 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 562629053cb33..8a2a00f56385d 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 a934a0f668841..324f1aade04a4 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 fe060ff482e71..8f78d54c70137 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 da5c692d2126c..23c143445abe9 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 914805c126f37..6bac1511d5599 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 f579e7a3d20ac..2d33ac4e5dea0 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 a0af5e5a9e001..aaa3e3529d416 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 13b21fbe1afe8..0b9b8fbcfd33a 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 85e5534fcf52a..a0d97383f0a3d 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 f081d13a5b0b1..eaead09a2f7a9 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 43ddfe6d58f3c..b3fbd8c765809 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 e3b727fafd3c8..67f2d750cc024 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 500ae8951ec4a..701ae33132dc3 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 c49d589572cbe..16142b2f8967c 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 c35e84154d80b..c67810bb17a8d 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 ccd79600a15a7..43c7887d3ef6c 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 d7b8ed583a518..ba4f0ccfe6485 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 2f79784ce5409..172ec2f09050c 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 973da6eab8d62..e29cad9c2a3fc 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 26974bbcecef7..08daf1bd80e42 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 987ee233810f7..277f0011c1cfb 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 e01c7ee998c31..455b71aff877a 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 7011088fa5d44..7a728e18a2901 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 81e9ac1b80876..bb726773bb5db 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 72427b6c53906..9e7344a8dfc05 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 a54c68a907b9b..898d0c0ec2317 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 396ac88bd06de..80f64d8df3d8f 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 6eccdb93d8c88..9ee237e97f0e4 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 64e7d0101b875..c27aff53b6797 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 27dc4ad8069b1..13a9d57e578d8 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 f740d8cb2d159..c20de257315f4 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 7c4139664afa4..e984896018096 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 f2dbc5a0d319a..99be8a5478c21 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 9626884be9dd9..2e9bd371e29cc 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 fe27eca773037..20d33a09f79e5 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 6ac169fed9b09..97429131a7c32 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 50a1b4345dc7e..22b5281ef38f0 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 2d9390245272c..dc5c7d11769b8 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 176a7ba004735..5765df4dafad9 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 756fa7d45630c..7a3c6a1387798 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 261283991059c..651f86e589804 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 73b3f4e34830b..ff858e81bb8dc 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 157ae16c5e7d8..f41e4d7d373f0 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 ed5ac89145c31..cf8dfd5469c9f 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 63b6cd3b42fea..fadbc53451905 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 e3d9a68afccbc..69706a324b63b 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 6dbc80c6a459a..95a10df5f8128 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 edc71b524e337..18ff6fe189638 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 14115fa52daa2..3f2c3f4fbd7ab 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 2dbed23677f7c..48a1fd3f78327 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 4a1bb2ea8776c..311ce2d64b20d 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 bde18d77b9add..a9ebfbcbf3322 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 7c2c1eab87bbb..2e294c30a3f76 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 5e6ea5f6d44e4..fccd9f3da0b9e 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 8370e0f7f9c86..ca48f3ffd50d1 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 463ed02a716b0..0fa93f37840a1 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 8cf9436ef5134..aeef29acd0eaf 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 15580a01f7add..dc22ebce804e6 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 d50a1b6a0be6c..424f4648d8e58 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 0e51da7dae175..8722376ab59e9 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 05404b16f16a9..99d943a2f6bdc 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 ddac182354693..f51221c419ef0 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 11d392f1fb1b3..538699512a3af 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 9b3db58ea9b29..b8d56f761b8df 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 c44b7389666f9..794c4f4016e62 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 59baf63d28400..a664daeb7f8cb 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 c34e65b2b4213..f0149c811f0d8 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 a3dc848344c4f..aa303aa3b8170 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 d58e7f2a28738..60f7689ecfa63 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 67bbd0967206b..2e788737e4d71 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 3e11f74f04abb..0dba1830cbd2e 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 57aeac9fcf87c..01eabad1596a9 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 c5221cd73d7ef..b4a673284811a 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 c5ff2bc46cd96..b3a77aa96752f 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 ba85db6f38bd4..587e0b9d4c5fa 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 4913df823b4df..d582b77060236 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 d6f148f559dba..b9b16d10b8c3c 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 2a368568f8ca5..fe1ef4817c6a9 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 861d72ea228a2..7e55e227cc07b 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 d6654db854f81..47b2ddd5022de 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 e0735e7ad24d7..e00ee11829547 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 84e9012be4e24..9d59b197d3ab7 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 2076f46e8ab7b..e5be0e52b9497 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 50aa840e6d748..9fc3a7acf7179 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 4257442ea33c8..2109f7ef1eafc 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 34ce5c66539d8..e01128554c726 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 a516e2bf9bc09..5f86cde261c5c 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 0bc6280393cff..bc03b0d27ca8d 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 1fda2c8060886..3f00cf7d18400 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 cbd0416cb69b8..9a2e83ef2d07c 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 751ba78b2820f..d9669812d2ad3 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 087c04e0ff01d..45f19a30e86a0 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 0f7e33ce340bb..fed766b23d96c 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 df1d22f2c86fb..53d2a47863b9d 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 bbb312842ce14..3bceefb831851 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 8c1be0a621975..26e6f568ce20c 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 050a51c958d57..b958588622fb4 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 86745deaad8be..49e0faf469320 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 560425dcb21b8..16d1a0c464c7d 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 57da2e038325a..a1d57241e0704 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 f81ddabf77c7f..6f91497a81c97 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 898759f67d24a..357d829627da0 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 5b1b1dd8ec3b4..994140ee1445d 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 cc8174d0d3203..f1e6c6a0e2fe5 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 6e2d62cce9276..c4037a70d9696 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 bb612c5b0df20..62be58605084b 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 9d994c423c9a0..ff4b43cb6b5fa 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 9f2069908437b..e091092b653a8 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 bec101a6d45a9..55d9a8bc63a39 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 93183f8dba475..af0e9572f38d2 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 4f9e3c2c1f644..468b6ca51a03c 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 a39907d5c7ede..835b5990ac2d5 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 c5211889f3f0c..b277c16dc4a95 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 cb8d73108748b..b74f080ede730 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 e3d3b3389ba14..04c1af4326bbd 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 d8b7c99d000aa..c0c1135b6d52c 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 2caef2d1b9e13..5731b8de52942 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 8c9de64687e27..fe4e38ee879bc 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 987aa9ee7e322..741e20d42db8d 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 8530c583b1654..6bac7f2a06e76 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 714dddf4ab6d3..db8dc0f64c47e 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 90d5bae56f439..ad6e668524cb2 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 8b87682384b68..627bb54dad396 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 ebed8e24a4841..37abb4be87f2d 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 10230065b9141..f2fa8a06bfd80 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 c5f8d0410d81a..0657f1a8faec9 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 c668981b40a7b..f9a5de40f4945 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 60e5a157bfc42..e3f2456c4c442 100644 --- a/src/test/run-pass/supported-cast.rs +++ b/src/test/run-pass/supported-cast.rs @@ -12,221 +12,221 @@ use std::libc; pub fn main() { let f = 1 as *libc::FILE; - info!("{}", f as int); - info!("{}", f as uint); - info!("{}", f as i8); - info!("{}", f as i16); - info!("{}", f as i32); - info!("{}", f as i64); - info!("{}", f as u8); - info!("{}", f as u16); - info!("{}", f as u32); - info!("{}", f as u64); - - info!("{}", 1 as int); - info!("{}", 1 as uint); - info!("{}", 1 as *libc::FILE); - info!("{}", 1 as i8); - info!("{}", 1 as i16); - info!("{}", 1 as i32); - info!("{}", 1 as i64); - info!("{}", 1 as u8); - info!("{}", 1 as u16); - info!("{}", 1 as u32); - info!("{}", 1 as u64); - info!("{}", 1 as f32); - info!("{}", 1 as f64); - - info!("{}", 1u as int); - info!("{}", 1u as uint); - info!("{}", 1u as *libc::FILE); - info!("{}", 1u as i8); - info!("{}", 1u as i16); - info!("{}", 1u as i32); - info!("{}", 1u as i64); - info!("{}", 1u as u8); - info!("{}", 1u as u16); - info!("{}", 1u as u32); - info!("{}", 1u as u64); - info!("{}", 1u as f32); - info!("{}", 1u as f64); - - info!("{}", 1i8 as int); - info!("{}", 1i8 as uint); - info!("{}", 1i8 as *libc::FILE); - info!("{}", 1i8 as i8); - info!("{}", 1i8 as i16); - info!("{}", 1i8 as i32); - info!("{}", 1i8 as i64); - info!("{}", 1i8 as u8); - info!("{}", 1i8 as u16); - info!("{}", 1i8 as u32); - info!("{}", 1i8 as u64); - info!("{}", 1i8 as f32); - info!("{}", 1i8 as f64); - - info!("{}", 1u8 as int); - info!("{}", 1u8 as uint); - info!("{}", 1u8 as *libc::FILE); - info!("{}", 1u8 as i8); - info!("{}", 1u8 as i16); - info!("{}", 1u8 as i32); - info!("{}", 1u8 as i64); - info!("{}", 1u8 as u8); - info!("{}", 1u8 as u16); - info!("{}", 1u8 as u32); - info!("{}", 1u8 as u64); - info!("{}", 1u8 as f32); - info!("{}", 1u8 as f64); - - info!("{}", 1i16 as int); - info!("{}", 1i16 as uint); - info!("{}", 1i16 as *libc::FILE); - info!("{}", 1i16 as i8); - info!("{}", 1i16 as i16); - info!("{}", 1i16 as i32); - info!("{}", 1i16 as i64); - info!("{}", 1i16 as u8); - info!("{}", 1i16 as u16); - info!("{}", 1i16 as u32); - info!("{}", 1i16 as u64); - info!("{}", 1i16 as f32); - info!("{}", 1i16 as f64); - - info!("{}", 1u16 as int); - info!("{}", 1u16 as uint); - info!("{}", 1u16 as *libc::FILE); - info!("{}", 1u16 as i8); - info!("{}", 1u16 as i16); - info!("{}", 1u16 as i32); - info!("{}", 1u16 as i64); - info!("{}", 1u16 as u8); - info!("{}", 1u16 as u16); - info!("{}", 1u16 as u32); - info!("{}", 1u16 as u64); - info!("{}", 1u16 as f32); - info!("{}", 1u16 as f64); - - info!("{}", 1i32 as int); - info!("{}", 1i32 as uint); - info!("{}", 1i32 as *libc::FILE); - info!("{}", 1i32 as i8); - info!("{}", 1i32 as i16); - info!("{}", 1i32 as i32); - info!("{}", 1i32 as i64); - info!("{}", 1i32 as u8); - info!("{}", 1i32 as u16); - info!("{}", 1i32 as u32); - info!("{}", 1i32 as u64); - info!("{}", 1i32 as f32); - info!("{}", 1i32 as f64); - - info!("{}", 1u32 as int); - info!("{}", 1u32 as uint); - info!("{}", 1u32 as *libc::FILE); - info!("{}", 1u32 as i8); - info!("{}", 1u32 as i16); - info!("{}", 1u32 as i32); - info!("{}", 1u32 as i64); - info!("{}", 1u32 as u8); - info!("{}", 1u32 as u16); - info!("{}", 1u32 as u32); - info!("{}", 1u32 as u64); - info!("{}", 1u32 as f32); - info!("{}", 1u32 as f64); - - info!("{}", 1i64 as int); - info!("{}", 1i64 as uint); - info!("{}", 1i64 as *libc::FILE); - info!("{}", 1i64 as i8); - info!("{}", 1i64 as i16); - info!("{}", 1i64 as i32); - info!("{}", 1i64 as i64); - info!("{}", 1i64 as u8); - info!("{}", 1i64 as u16); - info!("{}", 1i64 as u32); - info!("{}", 1i64 as u64); - info!("{}", 1i64 as f32); - info!("{}", 1i64 as f64); - - info!("{}", 1u64 as int); - info!("{}", 1u64 as uint); - info!("{}", 1u64 as *libc::FILE); - info!("{}", 1u64 as i8); - info!("{}", 1u64 as i16); - info!("{}", 1u64 as i32); - info!("{}", 1u64 as i64); - info!("{}", 1u64 as u8); - info!("{}", 1u64 as u16); - info!("{}", 1u64 as u32); - info!("{}", 1u64 as u64); - info!("{}", 1u64 as f32); - info!("{}", 1u64 as f64); - - info!("{}", 1u64 as int); - info!("{}", 1u64 as uint); - info!("{}", 1u64 as *libc::FILE); - info!("{}", 1u64 as i8); - info!("{}", 1u64 as i16); - info!("{}", 1u64 as i32); - info!("{}", 1u64 as i64); - info!("{}", 1u64 as u8); - info!("{}", 1u64 as u16); - info!("{}", 1u64 as u32); - info!("{}", 1u64 as u64); - info!("{}", 1u64 as f32); - info!("{}", 1u64 as f64); - - info!("{}", true as int); - info!("{}", true as uint); - info!("{}", true as *libc::FILE); - info!("{}", true as i8); - info!("{}", true as i16); - info!("{}", true as i32); - info!("{}", true as i64); - info!("{}", true as u8); - info!("{}", true as u16); - info!("{}", true as u32); - info!("{}", true as u64); - info!("{}", true as f32); - info!("{}", true as f64); - - info!("{}", 1. as int); - info!("{}", 1. as uint); - info!("{}", 1. as i8); - info!("{}", 1. as i16); - info!("{}", 1. as i32); - info!("{}", 1. as i64); - info!("{}", 1. as u8); - info!("{}", 1. as u16); - info!("{}", 1. as u32); - info!("{}", 1. as u64); - info!("{}", 1. as f32); - info!("{}", 1. as f64); - - info!("{}", 1f32 as int); - info!("{}", 1f32 as uint); - info!("{}", 1f32 as i8); - info!("{}", 1f32 as i16); - info!("{}", 1f32 as i32); - info!("{}", 1f32 as i64); - info!("{}", 1f32 as u8); - info!("{}", 1f32 as u16); - info!("{}", 1f32 as u32); - info!("{}", 1f32 as u64); - info!("{}", 1f32 as f32); - info!("{}", 1f32 as f64); - - info!("{}", 1f64 as int); - info!("{}", 1f64 as uint); - info!("{}", 1f64 as i8); - info!("{}", 1f64 as i16); - info!("{}", 1f64 as i32); - info!("{}", 1f64 as i64); - info!("{}", 1f64 as u8); - info!("{}", 1f64 as u16); - info!("{}", 1f64 as u32); - info!("{}", 1f64 as u64); - info!("{}", 1f64 as f32); - info!("{}", 1f64 as f64); + println!("{}", f as int); + println!("{}", f as uint); + println!("{}", f as i8); + println!("{}", f as i16); + println!("{}", f as i32); + println!("{}", f as i64); + println!("{}", f as u8); + println!("{}", f as u16); + println!("{}", f as u32); + println!("{}", f as u64); + + println!("{}", 1 as int); + println!("{}", 1 as uint); + println!("{}", 1 as *libc::FILE); + println!("{}", 1 as i8); + println!("{}", 1 as i16); + println!("{}", 1 as i32); + println!("{}", 1 as i64); + println!("{}", 1 as u8); + println!("{}", 1 as u16); + println!("{}", 1 as u32); + println!("{}", 1 as u64); + println!("{}", 1 as f32); + println!("{}", 1 as f64); + + println!("{}", 1u as int); + println!("{}", 1u as uint); + println!("{}", 1u as *libc::FILE); + println!("{}", 1u as i8); + println!("{}", 1u as i16); + println!("{}", 1u as i32); + println!("{}", 1u as i64); + println!("{}", 1u as u8); + println!("{}", 1u as u16); + println!("{}", 1u as u32); + println!("{}", 1u as u64); + println!("{}", 1u as f32); + println!("{}", 1u as f64); + + println!("{}", 1i8 as int); + println!("{}", 1i8 as uint); + println!("{}", 1i8 as *libc::FILE); + println!("{}", 1i8 as i8); + println!("{}", 1i8 as i16); + println!("{}", 1i8 as i32); + println!("{}", 1i8 as i64); + println!("{}", 1i8 as u8); + println!("{}", 1i8 as u16); + println!("{}", 1i8 as u32); + println!("{}", 1i8 as u64); + println!("{}", 1i8 as f32); + println!("{}", 1i8 as f64); + + println!("{}", 1u8 as int); + println!("{}", 1u8 as uint); + println!("{}", 1u8 as *libc::FILE); + println!("{}", 1u8 as i8); + println!("{}", 1u8 as i16); + println!("{}", 1u8 as i32); + println!("{}", 1u8 as i64); + println!("{}", 1u8 as u8); + println!("{}", 1u8 as u16); + println!("{}", 1u8 as u32); + println!("{}", 1u8 as u64); + println!("{}", 1u8 as f32); + println!("{}", 1u8 as f64); + + println!("{}", 1i16 as int); + println!("{}", 1i16 as uint); + println!("{}", 1i16 as *libc::FILE); + println!("{}", 1i16 as i8); + println!("{}", 1i16 as i16); + println!("{}", 1i16 as i32); + println!("{}", 1i16 as i64); + println!("{}", 1i16 as u8); + println!("{}", 1i16 as u16); + println!("{}", 1i16 as u32); + println!("{}", 1i16 as u64); + println!("{}", 1i16 as f32); + println!("{}", 1i16 as f64); + + println!("{}", 1u16 as int); + println!("{}", 1u16 as uint); + println!("{}", 1u16 as *libc::FILE); + println!("{}", 1u16 as i8); + println!("{}", 1u16 as i16); + println!("{}", 1u16 as i32); + println!("{}", 1u16 as i64); + println!("{}", 1u16 as u8); + println!("{}", 1u16 as u16); + println!("{}", 1u16 as u32); + println!("{}", 1u16 as u64); + println!("{}", 1u16 as f32); + println!("{}", 1u16 as f64); + + println!("{}", 1i32 as int); + println!("{}", 1i32 as uint); + println!("{}", 1i32 as *libc::FILE); + println!("{}", 1i32 as i8); + println!("{}", 1i32 as i16); + println!("{}", 1i32 as i32); + println!("{}", 1i32 as i64); + println!("{}", 1i32 as u8); + println!("{}", 1i32 as u16); + println!("{}", 1i32 as u32); + println!("{}", 1i32 as u64); + println!("{}", 1i32 as f32); + println!("{}", 1i32 as f64); + + println!("{}", 1u32 as int); + println!("{}", 1u32 as uint); + println!("{}", 1u32 as *libc::FILE); + println!("{}", 1u32 as i8); + println!("{}", 1u32 as i16); + println!("{}", 1u32 as i32); + println!("{}", 1u32 as i64); + println!("{}", 1u32 as u8); + println!("{}", 1u32 as u16); + println!("{}", 1u32 as u32); + println!("{}", 1u32 as u64); + println!("{}", 1u32 as f32); + println!("{}", 1u32 as f64); + + println!("{}", 1i64 as int); + println!("{}", 1i64 as uint); + println!("{}", 1i64 as *libc::FILE); + println!("{}", 1i64 as i8); + println!("{}", 1i64 as i16); + println!("{}", 1i64 as i32); + println!("{}", 1i64 as i64); + println!("{}", 1i64 as u8); + println!("{}", 1i64 as u16); + println!("{}", 1i64 as u32); + println!("{}", 1i64 as u64); + println!("{}", 1i64 as f32); + println!("{}", 1i64 as f64); + + println!("{}", 1u64 as int); + println!("{}", 1u64 as uint); + println!("{}", 1u64 as *libc::FILE); + println!("{}", 1u64 as i8); + println!("{}", 1u64 as i16); + println!("{}", 1u64 as i32); + println!("{}", 1u64 as i64); + println!("{}", 1u64 as u8); + println!("{}", 1u64 as u16); + println!("{}", 1u64 as u32); + println!("{}", 1u64 as u64); + println!("{}", 1u64 as f32); + println!("{}", 1u64 as f64); + + println!("{}", 1u64 as int); + println!("{}", 1u64 as uint); + println!("{}", 1u64 as *libc::FILE); + println!("{}", 1u64 as i8); + println!("{}", 1u64 as i16); + println!("{}", 1u64 as i32); + println!("{}", 1u64 as i64); + println!("{}", 1u64 as u8); + println!("{}", 1u64 as u16); + println!("{}", 1u64 as u32); + println!("{}", 1u64 as u64); + println!("{}", 1u64 as f32); + println!("{}", 1u64 as f64); + + println!("{}", true as int); + println!("{}", true as uint); + println!("{}", true as *libc::FILE); + println!("{}", true as i8); + println!("{}", true as i16); + println!("{}", true as i32); + println!("{}", true as i64); + println!("{}", true as u8); + println!("{}", true as u16); + println!("{}", true as u32); + println!("{}", true as u64); + println!("{}", true as f32); + println!("{}", true as f64); + + println!("{}", 1. as int); + println!("{}", 1. as uint); + println!("{}", 1. as i8); + println!("{}", 1. as i16); + println!("{}", 1. as i32); + println!("{}", 1. as i64); + println!("{}", 1. as u8); + println!("{}", 1. as u16); + println!("{}", 1. as u32); + println!("{}", 1. as u64); + println!("{}", 1. as f32); + println!("{}", 1. as f64); + + println!("{}", 1f32 as int); + println!("{}", 1f32 as uint); + println!("{}", 1f32 as i8); + println!("{}", 1f32 as i16); + println!("{}", 1f32 as i32); + println!("{}", 1f32 as i64); + println!("{}", 1f32 as u8); + println!("{}", 1f32 as u16); + println!("{}", 1f32 as u32); + println!("{}", 1f32 as u64); + println!("{}", 1f32 as f32); + println!("{}", 1f32 as f64); + + println!("{}", 1f64 as int); + println!("{}", 1f64 as uint); + println!("{}", 1f64 as i8); + println!("{}", 1f64 as i16); + println!("{}", 1f64 as i32); + println!("{}", 1f64 as i64); + println!("{}", 1f64 as u8); + println!("{}", 1f64 as u16); + println!("{}", 1f64 as u32); + println!("{}", 1f64 as u64); + println!("{}", 1f64 as f32); + println!("{}", 1f64 as f64); } diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index 78cc48e4ed4b3..781a50b87a7dd 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 05b3f98ea08cd..5cf6c2af12b85 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 cbab11003b17d..55235974e1307 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 830aecfa86cc9..8eaa7f2e31d95 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 844e39e584ed2..6299cfdee202c 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 d0c5efbfa227b..275c99f99a95d 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 0b1e9580a1e22..6d06578c6cd1d 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 799ee6093008b..9559e5c84afbb 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 0ed76593b9e84..176b64e41d00f 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 411730dac7859..6418921172a36 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 f2493e5d10223..a4e6be4f2d528 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 2bb839aa2cfe7..873269190c527 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 b00689db26b8b..dc862f201c244 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 a9e2979f7dbcc..840ab18dafa3d 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 a0c2a489bf64a..11d1b9ecbfe3a 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 50af6cb71c1f4..ed72a758c78b8 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 4898ef1cd0ae2..adbbf1aec9afc 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 48a49996aeebb..7bb0fe5faa184 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 b1fc4e76ea084..c5d55ff0386ec 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 96d61b377af5c..06f73777032d9 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 077bbdfb0baa4..7f11e7b7df5c8 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 fc37e1c39ed03..2d05eb2219671 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 69e28e30d0920..a5659a4648e03 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 a85861d2aa5d4..9bf98baa303bc 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 1520a8b7e611c..9531563fcbef2 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 7014ad5df141d..9b42a25956ee9 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 7ffbade05c1cc..c15a7fcdf29da 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 f190fd2cb9366..cd20917a17909 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 10726a9c396b3..0e4f4194a549d 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 ed7ba12ea0f2f..3e1a232115f7d 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 a21aa4a9a6246..8ef98901e9f06 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 57bc3bda9636a..1f16b5fdb5c67 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 fe2506ad686ab..bd8b1f0f088ab 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 01370ed12b443..b2cf771faee3c 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 4ec30d6e02a0b..bd44bdd51cd85 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 c08c62b47a225..14ba368bdfad6 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 7bc3c1fc1f4dc..c6cb0dd65e772 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(); } } From a921dc487319e926467f8e6afd9900ed2f03aaa9 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 8 Mar 2014 22:36:10 -0800 Subject: [PATCH 2/5] rustc: Remove compiler support for __log_level() This commit removes all internal support for the previously used __log_level() expression. The logging subsystem was previously modified to not rely on this magical expression. This also removes the only other function to use the module_data map in trans, decl_gc_metadata. It appears that this is an ancient function from a GC only used long ago. This does not remove the crate map entirely, as libgreen still uses it to hook in to the event loop provided by libgreen. --- src/librustc/middle/cfg/construct.rs | 1 - src/librustc/middle/dataflow.rs | 1 - src/librustc/middle/liveness.rs | 5 +- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc/middle/moves.rs | 1 - src/librustc/middle/trans/base.rs | 104 +--------------------- src/librustc/middle/trans/context.rs | 2 - src/librustc/middle/trans/debuginfo.rs | 1 - src/librustc/middle/trans/expr.rs | 66 +------------- src/librustc/middle/ty.rs | 1 - src/librustc/middle/typeck/check/mod.rs | 3 - src/libstd/rt/crate_map.rs | 99 ++++---------------- src/libsyntax/ast.rs | 3 - src/libsyntax/ext/base.rs | 2 +- src/libsyntax/fold.rs | 1 - src/libsyntax/parse/parser.rs | 8 +- src/libsyntax/print/pprust.rs | 5 -- src/libsyntax/visit.rs | 1 - 18 files changed, 22 insertions(+), 284 deletions(-) diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 0100a82a9d5aa..2306a25592bf4 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -408,7 +408,6 @@ impl CFGBuilder { self.straightline(expr, pred, [e]) } - ast::ExprLogLevel | ast::ExprMac(..) | ast::ExprInlineAsm(..) | ast::ExprFnBlock(..) | diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 57b5be4e96069..683ef11aff152 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -613,7 +613,6 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { self.walk_exprs([l, r], in_out, loop_scopes); } - ast::ExprLogLevel | ast::ExprLit(..) | ast::ExprPath(..) => {} diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index fa435378ab7df..38cbde70ad18b 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -541,7 +541,7 @@ fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) { // otherwise, live nodes are not required: ExprIndex(..) | ExprField(..) | ExprVstore(..) | ExprVec(..) | - ExprCall(..) | ExprMethodCall(..) | ExprTup(..) | ExprLogLevel | + ExprCall(..) | ExprMethodCall(..) | ExprTup(..) | ExprBinary(..) | ExprAddrOf(..) | ExprCast(..) | ExprUnary(..) | ExprBreak(_) | ExprAgain(_) | ExprLit(_) | ExprRet(..) | ExprBlock(..) | @@ -1271,7 +1271,6 @@ impl Liveness { }) } - ExprLogLevel | ExprLit(..) => { succ } @@ -1521,7 +1520,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) { // no correctness conditions related to liveness ExprCall(..) | ExprMethodCall(..) | ExprIf(..) | ExprMatch(..) | ExprWhile(..) | ExprLoop(..) | ExprIndex(..) | ExprField(..) | - ExprVstore(..) | ExprVec(..) | ExprTup(..) | ExprLogLevel | + ExprVstore(..) | ExprVec(..) | ExprTup(..) | ExprBinary(..) | ExprCast(..) | ExprUnary(..) | ExprRet(..) | ExprBreak(..) | ExprAgain(..) | ExprLit(_) | ExprBlock(..) | diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index c07cd2570a30b..127f835d5f6ef 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -469,7 +469,7 @@ impl MemCategorizationContext { ast::ExprUnary(..) | ast::ExprMethodCall(..) | ast::ExprCast(..) | ast::ExprVstore(..) | ast::ExprVec(..) | ast::ExprTup(..) | ast::ExprIf(..) | - ast::ExprLogLevel | ast::ExprBinary(..) | ast::ExprWhile(..) | + ast::ExprBinary(..) | ast::ExprWhile(..) | ast::ExprBlock(..) | ast::ExprLoop(..) | ast::ExprMatch(..) | ast::ExprLit(..) | ast::ExprBreak(..) | ast::ExprMac(..) | ast::ExprAgain(..) | ast::ExprStruct(..) | ast::ExprRepeat(..) | diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index b52ec7be63114..22b3fb8ad6e4f 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -503,7 +503,6 @@ impl VisitContext { self.use_expr(base, Read); } - ExprLogLevel | ExprInlineAsm(..) | ExprBreak(..) | ExprAgain(..) | diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index c2f5d0806a798..a2ee57d6df1ae 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -32,7 +32,7 @@ use driver::session::{Session, NoDebugInfo, FullDebugInfo}; use driver::driver::OutputFilenames; use driver::driver::{CrateAnalysis, CrateTranslation}; use lib::llvm::{ModuleRef, ValueRef, BasicBlockRef}; -use lib::llvm::{llvm, True, Vector}; +use lib::llvm::{llvm, Vector}; use lib; use metadata::common::LinkMeta; use metadata::{csearch, encoder}; @@ -2404,70 +2404,6 @@ pub fn trap(bcx: &Block) { } } -pub fn decl_gc_metadata(ccx: &CrateContext, llmod_id: &str) { - if !ccx.sess.opts.gc || !ccx.uses_gc { - return; - } - - let gc_metadata_name = ~"_gc_module_metadata_" + llmod_id; - let gc_metadata = gc_metadata_name.with_c_str(|buf| { - unsafe { - llvm::LLVMAddGlobal(ccx.llmod, Type::i32().to_ref(), buf) - } - }); - unsafe { - llvm::LLVMSetGlobalConstant(gc_metadata, True); - lib::llvm::SetLinkage(gc_metadata, lib::llvm::ExternalLinkage); - - let mut module_data = ccx.module_data.borrow_mut(); - module_data.get().insert(~"_gc_module_metadata", gc_metadata); - } -} - -pub fn create_module_map(ccx: &CrateContext) -> (ValueRef, uint) { - let str_slice_type = Type::struct_([Type::i8p(), ccx.int_type], false); - let elttype = Type::struct_([str_slice_type, ccx.int_type], false); - let maptype = { - let module_data = ccx.module_data.borrow(); - Type::array(&elttype, module_data.get().len() as u64) - }; - let map = "_rust_mod_map".with_c_str(|buf| { - unsafe { - llvm::LLVMAddGlobal(ccx.llmod, maptype.to_ref(), buf) - } - }); - lib::llvm::SetLinkage(map, lib::llvm::InternalLinkage); - let mut elts: Vec = Vec::new(); - - // This is not ideal, but the borrow checker doesn't - // like the multiple borrows. At least, it doesn't - // like them on the current snapshot. (2013-06-14) - let keys = { - let mut keys = Vec::new(); - let module_data = ccx.module_data.borrow(); - for (k, _) in module_data.get().iter() { - keys.push(k.clone()); - } - keys - }; - - for key in keys.iter() { - let llstrval = C_str_slice(ccx, token::intern_and_get_ident(*key)); - let module_data = ccx.module_data.borrow(); - let val = *module_data.get().find_equiv(key).unwrap(); - let v_ptr = p2i(ccx, val); - let elt = C_struct([ - llstrval, - v_ptr - ], false); - elts.push(elt); - } - unsafe { - llvm::LLVMSetInitializer(map, C_array(elttype, elts.as_slice())); - } - return (map, keys.len()) -} - pub fn symname(name: &str, hash: &str, vers: &str) -> ~str { let path = [PathName(token::intern(name))]; link::exported_name(ast_map::Values(path.iter()).chain(None), hash, vers) @@ -2489,11 +2425,8 @@ pub fn decl_crate_map(sess: session::Session, mapmeta: LinkMeta, mapmeta.crateid.version_or_default()) }; - let slicetype = Type::struct_([int_type, int_type], false); let maptype = Type::struct_([ Type::i32(), // version - slicetype, // child modules - slicetype, // sub crate-maps int_type.ptr_to(), // event loop factory ], false); let map = sym_name.with_c_str(|buf| { @@ -2513,22 +2446,6 @@ pub fn decl_crate_map(sess: session::Session, mapmeta: LinkMeta, } pub fn fill_crate_map(ccx: @CrateContext, map: ValueRef) { - let mut subcrates: Vec = Vec::new(); - let mut i = 1; - let cstore = ccx.sess.cstore; - while cstore.have_crate_data(i) { - let cdata = cstore.get_crate_data(i); - let nm = symname(format!("_rust_crate_map_{}", cdata.name), - cstore.get_crate_hash(i).as_str(), - cstore.get_crate_id(i).version_or_default()); - let cr = nm.with_c_str(|buf| { - unsafe { - llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf) - } - }); - subcrates.push(p2i(ccx, cr)); - i += 1; - } let event_loop_factory = match ccx.tcx.lang_items.event_loop_factory() { Some(did) => unsafe { if is_local(did) { @@ -2545,26 +2462,8 @@ pub fn fill_crate_map(ccx: @CrateContext, map: ValueRef) { None => C_null(ccx.int_type.ptr_to()) }; unsafe { - let maptype = Type::array(&ccx.int_type, subcrates.len() as u64); - let vec_elements = "_crate_map_child_vectors".with_c_str(|buf| { - llvm::LLVMAddGlobal(ccx.llmod, maptype.to_ref(), buf) - }); - lib::llvm::SetLinkage(vec_elements, lib::llvm::InternalLinkage); - - llvm::LLVMSetInitializer(vec_elements, - C_array(ccx.int_type, subcrates.as_slice())); - let (mod_map, mod_count) = create_module_map(ccx); - llvm::LLVMSetInitializer(map, C_struct( [C_i32(2), - C_struct([ - p2i(ccx, mod_map), - C_uint(ccx, mod_count) - ], false), - C_struct([ - p2i(ccx, vec_elements), - C_uint(ccx, subcrates.len()) - ], false), event_loop_factory, ], false)); } @@ -2667,7 +2566,6 @@ pub fn trans_crate(sess: session::Session, trans_mod(ccx, &krate.module); } - decl_gc_metadata(ccx, llmod_id); fill_crate_map(ccx, ccx.crate_map); // win32: wart with exporting crate_map symbol diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs index 517bef52a9939..80dcfc9028715 100644 --- a/src/librustc/middle/trans/context.rs +++ b/src/librustc/middle/trans/context.rs @@ -95,7 +95,6 @@ pub struct CrateContext { // Cache of closure wrappers for bare fn's. closure_bare_wrapper_cache: RefCell>, - module_data: RefCell>, lltypes: RefCell>, llsizingtypes: RefCell>, adt_reprs: RefCell>, @@ -207,7 +206,6 @@ impl CrateContext { extern_const_values: RefCell::new(DefIdMap::new()), impl_method_cache: RefCell::new(HashMap::new()), closure_bare_wrapper_cache: RefCell::new(HashMap::new()), - module_data: RefCell::new(HashMap::new()), lltypes: RefCell::new(HashMap::new()), llsizingtypes: RefCell::new(HashMap::new()), adt_reprs: RefCell::new(HashMap::new()), diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 6ade20d29136d..dd6a3e61b69e7 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -2539,7 +2539,6 @@ fn populate_scope_map(cx: &CrateContext, scope_map.insert(exp.id, scope_stack.last().unwrap().scope_metadata); match exp.node { - ast::ExprLogLevel | ast::ExprLit(_) | ast::ExprBreak(_) | ast::ExprAgain(_) | diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index d143d6743052c..bf2d192d0de23 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -34,8 +34,7 @@ #[allow(non_camel_case_types)]; use back::abi; -use back::link; -use lib::llvm::{ValueRef, llvm, SetLinkage, False}; +use lib::llvm::{ValueRef, llvm}; use lib; use metadata::csearch; use middle::trans::_match; @@ -74,9 +73,7 @@ use middle::trans::type_::Type; use std::vec; use std::vec_ng::Vec; use syntax::ast; -use syntax::ast_map; use syntax::codemap; -use syntax::parse::token; use syntax::print::pprust::{expr_to_str}; // Destinations @@ -455,9 +452,6 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>, // Datum output mode means this is a scalar cast: trans_imm_cast(bcx, val, expr.id) } - ast::ExprLogLevel => { - trans_log_level(bcx) - } _ => { bcx.tcx().sess.span_bug( expr.span, @@ -1671,64 +1665,6 @@ fn trans_assign_op<'a>( return result_datum.store_to(bcx, dst_datum.val); } -fn trans_log_level<'a>(bcx: &'a Block<'a>) -> DatumBlock<'a, Expr> { - let _icx = push_ctxt("trans_log_level"); - let ccx = bcx.ccx(); - - let (modpath, modname) = { - let srccrate = { - let external_srcs = ccx.external_srcs.borrow(); - match external_srcs.get().find(&bcx.fcx.id) { - Some(&src) => { - ccx.sess.cstore.get_crate_data(src.krate).name.clone() - } - None => ccx.link_meta.crateid.name.to_str(), - } - }; - bcx.tcx().map.with_path(bcx.fcx.id, |path| { - let first = ast_map::PathMod(token::intern(srccrate)); - let mut path = Some(first).move_iter().chain(path).filter(|e| { - match *e { - ast_map::PathMod(_) => true, - _ => false - } - }); - let modpath: Vec = path.collect(); - let modname = ast_map::path_to_str(ast_map::Values(modpath.iter())); - (modpath, modname) - }) - }; - - let module_data_exists; - { - let module_data = ccx.module_data.borrow(); - module_data_exists = module_data.get().contains_key(&modname); - } - - let global = if module_data_exists { - let mut module_data = ccx.module_data.borrow_mut(); - module_data.get().get_copy(&modname) - } else { - let s = link::mangle_internal_name_by_path_and_seq( - ast_map::Values(modpath.iter()).chain(None), "loglevel"); - let global; - unsafe { - global = s.with_c_str(|buf| { - llvm::LLVMAddGlobal(ccx.llmod, Type::i32().to_ref(), buf) - }); - llvm::LLVMSetGlobalConstant(global, False); - llvm::LLVMSetInitializer(global, C_null(Type::i32())); - lib::llvm::SetLinkage(global, lib::llvm::InternalLinkage); - } - { - let mut module_data = ccx.module_data.borrow_mut(); - module_data.get().insert(modname, global); - global - } - }; - - immediate_rvalue_bcx(bcx, Load(bcx, global), ty::mk_u32()).to_expr_datumblock() -} fn auto_ref<'a>(bcx: &'a Block<'a>, datum: Datum, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c0ad18d9520e3..e1dddda01f7e1 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3391,7 +3391,6 @@ pub fn expr_kind(tcx: ctxt, ast::ExprForLoop(..) => fail!("non-desugared expr_for_loop"), - ast::ExprLogLevel | ast::ExprLit(_) | // Note: LitStr is carved out above ast::ExprUnary(..) | ast::ExprAddrOf(..) | diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 51efcb7d1c387..b3f7adc89e898 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -2848,9 +2848,6 @@ fn check_expr_with_unifier(fcx: @FnCtxt, } fcx.write_bot(id); } - ast::ExprLogLevel => { - fcx.write_ty(id, ty::mk_u32()) - } ast::ExprParen(a) => { check_expr_with_opt_hint_and_lvalue_pref(fcx, a, expected, lvalue_pref); fcx.write_ty(id, fcx.expr_ty(a)); diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs index ff54a80ce997f..c6d5a80208b1f 100644 --- a/src/libstd/rt/crate_map.rs +++ b/src/libstd/rt/crate_map.rs @@ -9,13 +9,14 @@ // except according to those terms. use cast; -use cmp::TotalOrd; -use container::MutableSet; -use iter::Iterator; use option::{Some, None, Option}; use ptr::RawPtr; use rt::rtio::EventLoop; -use vec::{ImmutableVector, OwnedVector}; + +#[cfg(stage0)] use cmp::TotalOrd; +#[cfg(stage0)] use container::MutableSet; +#[cfg(stage0)] use iter::Iterator; +#[cfg(stage0)] use vec::{ImmutableVector, OwnedVector}; // Need to tell the linker on OS X to not barf on undefined symbols // and instead look them up at runtime, which we need to resolve @@ -24,17 +25,24 @@ use vec::{ImmutableVector, OwnedVector}; #[link_args = "-Wl,-U,__rust_crate_map_toplevel"] extern {} +#[cfg(stage0)] pub struct ModEntry<'a> { name: &'a str, log_level: *mut u32 } +#[cfg(stage0)] pub struct CrateMap<'a> { version: i32, entries: &'a [ModEntry<'a>], children: &'a [&'a CrateMap<'a>], event_loop_factory: Option ~EventLoop>, } +#[cfg(not(stage0))] +pub struct CrateMap<'a> { + version: i32, + event_loop_factory: Option ~EventLoop>, +} // When working on android, apparently weak symbols don't work so well for // finding the crate map, and neither does dlopen + dlsym. This is mainly a @@ -114,6 +122,7 @@ pub fn get_crate_map() -> Option<&'static CrateMap<'static>> { } } +#[cfg(stage0)] fn version(crate_map: &CrateMap) -> i32 { match crate_map.version { 2 => return 2, @@ -121,6 +130,7 @@ fn version(crate_map: &CrateMap) -> i32 { } } +#[cfg(stage0)] fn do_iter_crate_map<'a>( crate_map: &'a CrateMap<'a>, f: |&'a ModEntry<'a>|, @@ -149,87 +159,8 @@ fn do_iter_crate_map<'a>( } /// Iterates recursively over `crate_map` and all child crate maps +#[cfg(stage0)] pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: |&'a ModEntry<'a>|) { let mut v = ~[]; do_iter_crate_map(crate_map, f, &mut v); } - -#[cfg(test)] -mod tests { - use option::None; - use rt::crate_map::{CrateMap, ModEntry, iter_crate_map}; - - #[test] - fn iter_crate_map_duplicates() { - let mut level3: u32 = 3; - - let entries = [ - ModEntry { name: "c::m1", log_level: &mut level3}, - ]; - - let child_crate = CrateMap { - version: 2, - entries: entries, - children: &[], - event_loop_factory: None, - }; - - let root_crate = CrateMap { - version: 2, - entries: &[], - children: &[&child_crate, &child_crate], - event_loop_factory: None, - }; - - let mut cnt = 0; - unsafe { - iter_crate_map(&root_crate, |entry| { - assert!(*entry.log_level == 3); - cnt += 1; - }); - assert!(cnt == 1); - } - } - - #[test] - fn iter_crate_map_follow_children() { - let mut level2: u32 = 2; - let mut level3: u32 = 3; - let child_crate2 = CrateMap { - version: 2, - entries: &[ - ModEntry { name: "c::m1", log_level: &mut level2}, - ModEntry { name: "c::m2", log_level: &mut level3}, - ], - children: &[], - event_loop_factory: None, - }; - - let child_crate1 = CrateMap { - version: 2, - entries: &[ - ModEntry { name: "t::f1", log_level: &mut 1}, - ], - children: &[&child_crate2], - event_loop_factory: None, - }; - - let root_crate = CrateMap { - version: 2, - entries: &[ - ModEntry { name: "t::f2", log_level: &mut 0}, - ], - children: &[&child_crate1], - event_loop_factory: None, - }; - - let mut cnt = 0; - unsafe { - iter_crate_map(&root_crate, |entry| { - assert!(*entry.log_level == cnt); - cnt += 1; - }); - assert!(cnt == 4); - } - } -} diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 3e600249a7df3..4ef46573e23a5 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -529,9 +529,6 @@ pub enum Expr_ { ExprAgain(Option), ExprRet(Option<@Expr>), - /// Gets the log level for the enclosing module - ExprLogLevel, - ExprInlineAsm(InlineAsm), ExprMac(Mac), diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index b575cfaade644..997bfcc2e94da 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -120,7 +120,7 @@ impl MacResult { pub fn raw_dummy_expr(sp: codemap::Span) -> @ast::Expr { @ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprLogLevel, + node: ast::ExprTup(Vec::new()), span: sp } } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 0b56cd07c887f..8cc74641db85f 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -816,7 +816,6 @@ pub fn noop_fold_expr(e: @Expr, folder: &mut T) -> @Expr { ExprIndex(folder.fold_expr(el), folder.fold_expr(er)) } ExprPath(ref pth) => ExprPath(folder.fold_path(pth)), - ExprLogLevel => ExprLogLevel, ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|x| folder.fold_ident(x))), ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|x| folder.fold_ident(x))), ExprRet(ref e) => { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 040c4da68858f..f52effb8c81d7 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -25,7 +25,7 @@ use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain}; use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox}; use ast::{ExprBreak, ExprCall, ExprCast}; use ast::{ExprField, ExprFnBlock, ExprIf, ExprIndex}; -use ast::{ExprLit, ExprLogLevel, ExprLoop, ExprMac}; +use ast::{ExprLit, ExprLoop, ExprMac}; use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc}; use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary}; use ast::{ExprVec, ExprVstore, ExprVstoreSlice}; @@ -1886,12 +1886,6 @@ impl Parser { } } hi = self.last_span.hi; - } else if self.eat_keyword(keywords::__LogLevel) { - // LOG LEVEL expression - self.expect(&token::LPAREN); - ex = ExprLogLevel; - hi = self.span.hi; - self.expect(&token::RPAREN); } else if self.eat_keyword(keywords::Return) { // RETURN expression if can_begin_expr(&self.token) { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 36c3922048367..b199047609493 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1490,11 +1490,6 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) -> io::IoResult<()> { _ => () } } - ast::ExprLogLevel => { - try!(word(&mut s.s, "__log_level")); - try!(popen(s)); - try!(pclose(s)); - } ast::ExprInlineAsm(ref a) => { if a.volatile { try!(word(&mut s.s, "__volatile__ asm!")); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 538528fb1484a..880fce580831b 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -743,7 +743,6 @@ pub fn walk_expr>(visitor: &mut V, expression: &Expr, en ExprRet(optional_expression) => { walk_expr_opt(visitor, optional_expression, env.clone()) } - ExprLogLevel => {} ExprMac(ref macro) => visitor.visit_mac(macro, env.clone()), ExprParen(subexpression) => { visitor.visit_expr(subexpression, env.clone()) From 0b3df19c6a02a743dae904245c6f98424e75af8c Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 12 Mar 2014 09:49:38 -0700 Subject: [PATCH 3/5] rustc: Tweak where -lmorestack is on link commands In removing many fields from the crate map, executables no longer always have an explicit dependency on all upstream libraries. This means that the linker is no longer picking them up as it used to. To the best of my knowledge, the current situation is happening: * On linux, we're passing the --as-needed flag to the linker, meaning that libraries are stripped out if there are no references to symbols in them. * Executables may not reference libstd at all, such as "fn main() {}" * When linking, the linker will discard libstd because there are no references to symbols in it. I presume that this means that all previous libs have had all their symbols resolved, so none of the libs are pulling in libstd as a dependency. * The only real dependence on libstd comes from the rust_stack_exhausted symbol (which comes from libmorestack), but -lmorestack is at the end so by the time this comes up libstd is completely gone, leading to undefined references to rust_stack_exhausted I'm not entirely convinced that this is what's happening, but it appears to be along these lines. The one thing that I'm sure of is that removing the crate map (and hence implicit dependency on all upstream libraries) has changed how objects depend on upstream libraries. --- src/librustc/back/link.rs | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 1c1121f0940ce..d68fa0ca24134 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -1085,6 +1085,23 @@ fn link_args(sess: Session, ~"-o", out_filename.as_str().unwrap().to_owned(), obj_filename.as_str().unwrap().to_owned()]); + // Stack growth requires statically linking a __morestack function. Note + // that this is listed *before* all other libraries, even though it may be + // used to resolve symbols in other libraries. The only case that this + // wouldn't be pulled in by the object file is if the object file had no + // functions. + // + // If we're building an executable, there must be at least one function (the + // main function), and if we're building a dylib then we don't need it for + // later libraries because they're all dylibs (not rlibs). + // + // I'm honestly not entirely sure why this needs to come first. Apparently + // the --as-needed flag above sometimes strips out libstd from the command + // line, but inserting this farther to the left makes the + // "rust_stack_exhausted" symbol an outstanding undefined symbol, which + // flags libstd as a required library (or whatever provides the symbol). + args.push(~"-lmorestack"); + // When linking a dynamic library, we put the metadata into a section of the // executable. This metadata is in a separate object file from the main // object file, so we link that in here. @@ -1200,11 +1217,13 @@ fn link_args(sess: Session, args.push_all(rpath::get_rpath_flags(sess, out_filename).as_slice()); } - // Stack growth requires statically linking a __morestack function - args.push(~"-lmorestack"); - // compiler-rt contains implementations of low-level LLVM helpers - // It should go before platform and user libraries, so it has first dibs - // at resolving symbols that also appear in libgcc. + // compiler-rt contains implementations of low-level LLVM helpers. This is + // used to resolve symbols from the object file we just created, as well as + // any system static libraries that may be expecting gcc instead. Most + // symbols in libgcc also appear in compiler-rt. + // + // This is the end of the command line, so this library is used to resolve + // *all* undefined symbols in all other libraries, and this is intentional. args.push(~"-lcompiler-rt"); // Finally add all the linker arguments provided on the command line along From 17ad504fef35191fe53874bd2fe77ffd14d8e1b9 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 13 Mar 2014 18:47:43 -0700 Subject: [PATCH 4/5] rustc: Topographically sort rust dependencies This commit starts to topographically sort rust dependencies on the linker command line. The reason for this is that linkers use right-hand libraries to resolve left-hand libraries symbols, which is especially crucial for us because we're using --as-needed on linux. --- src/librustc/metadata/cstore.rs | 32 ++++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index d502018da17cf..e6628da89f52b 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -143,16 +143,44 @@ impl CStore { self.used_link_args.with_mut(|s| s.clear()); } + // This method is used when generating the command line to pass through to + // system linker. The linker expects undefined symbols on the left of the + // command line to be defined in libraries on the right, not the other way + // around. For more info, see some comments in the add_used_library function + // below. + // + // In order to get this left-to-right dependency ordering, we perform a + // topological sort of all crates putting the leaves at the right-most + // positions. pub fn get_used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option)> { + let mut ordering = Vec::new(); + fn visit(cstore: &CStore, cnum: ast::CrateNum, + ordering: &mut Vec) { + if ordering.as_slice().contains(&cnum) { return } + let meta = cstore.get_crate_data(cnum); + for (_, &dep) in meta.cnum_map.borrow().get().iter() { + visit(cstore, dep, ordering); + } + ordering.push(cnum); + }; + for (&num, _) in self.metas.borrow().get().iter() { + visit(self, num, &mut ordering); + } + ordering.as_mut_slice().reverse(); + let ordering = ordering.as_slice(); let used_crate_sources = self.used_crate_sources.borrow(); - used_crate_sources.get() + let mut libs = used_crate_sources.get() .iter() .map(|src| (src.cnum, match prefer { RequireDynamic => src.dylib.clone(), RequireStatic => src.rlib.clone(), })) - .collect() + .collect(); + libs.sort_by(|&(a, _), &(b, _)| { + ordering.position_elem(&a).cmp(&ordering.position_elem(&b)) + }); + libs } pub fn add_used_library(&self, lib: ~str, kind: NativeLibaryKind) { From 0015cab1fd7b4b47030c808a825bb5594cc1d4ac Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 12 Mar 2014 23:34:31 -0700 Subject: [PATCH 5/5] Test fixes and rebase conflicts This commit switches over the backtrace infrastructure from piggy-backing off the RUST_LOG environment variable to using the RUST_BACKTRACE environment variable (logging is now disabled in libstd). --- mk/crates.mk | 2 +- src/doc/index.md | 1 + src/libflate/lib.rs | 1 + src/liblog/lib.rs | 21 ++++++++++++++++++--- src/libnative/io/file_win32.rs | 2 +- src/librand/lib.rs | 5 ++++- src/librustc/lib.rs | 2 +- src/librustc/metadata/cstore.rs | 2 +- src/libstd/os.rs | 11 ++++------- src/libstd/rt/backtrace.rs | 22 +++++++++++++++++++--- src/libstd/rt/unwind.rs | 2 ++ src/libsync/lib.rs | 4 ++-- src/libworkcache/lib.rs | 2 ++ src/test/run-pass/backtrace.rs | 4 ++-- src/test/run-pass/comm.rs | 2 +- src/test/run-pass/dead-code-one-arm-if.rs | 3 +-- src/test/run-pass/parse-fail.rs | 2 ++ 17 files changed, 63 insertions(+), 25 deletions(-) diff --git a/mk/crates.mk b/mk/crates.mk index 7c12b4edacb5b..e3534b6664cbe 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -82,7 +82,7 @@ DEPS_test := std collections getopts serialize term time DEPS_time := std serialize DEPS_rand := std DEPS_url := std collections -DEPS_workcache := std serialize collections std +DEPS_workcache := std serialize collections log DEPS_log := std sync TOOL_DEPS_compiletest := test green rustuv getopts diff --git a/src/doc/index.md b/src/doc/index.md index 0db15db9c33dc..5bcfd8e830533 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -51,6 +51,7 @@ li {list-style-type: none; } * [The `uuid` 128-bit universally unique identifier library](uuid/index.html) * [The `url` library](url/index.html) * [The `workcache` library](workcache/index.html) +* [The `log` library](log/index.html) # Tooling diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 2482359c6325a..d9f7ae9a856ca 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -18,6 +18,7 @@ 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)]; diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 6d2afa2a64310..3ff7ee390f1e8 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -12,9 +12,24 @@ 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. +## Example + +``` +#[feature(phase)]; +#[phase(syntax, link)] extern crate log; + +fn main() { + debug!("this is a debug {}", "message"); + error!("this is printed by default"); + + if log_enabled!(log::INFO) { + let x = 3 * 4; // expensive computation + info!("the answer was: {}", x); + } +} +``` + +## Logging Macros There are five macros that the logging subsystem uses: diff --git a/src/libnative/io/file_win32.rs b/src/libnative/io/file_win32.rs index 8f4f9259ab7ac..c5ae4f00017a9 100644 --- a/src/libnative/io/file_win32.rs +++ b/src/libnative/io/file_win32.rs @@ -238,7 +238,7 @@ 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); } } } diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 70e5bb9281610..dc4e3e50b6538 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -70,9 +70,12 @@ println!("{:?}", tuple_ptr) 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)]; +#[feature(macro_rules, managed_boxes, phase)]; #[allow(deprecated_owned_vector)]; +#[cfg(test)] +#[phase(syntax, link)] extern crate log; + use std::cast; use std::kinds::marker; use std::local_data; diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 66749cf5403a3..00cde129d1e40 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -410,7 +410,7 @@ pub fn monitor(f: proc()) { let xs = [ ~"the compiler hit an unexpected failure path. this is a bug.", "we would appreciate a bug report: " + BUG_REPORT_URL, - ~"run with `RUST_LOG=std::rt::backtrace` for a backtrace", + ~"run with `RUST_BACKTRACE=1` for a backtrace", ]; for note in xs.iter() { emitter.emit(None, *note, diagnostic::Note) diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index e6628da89f52b..deadfb429046a 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -176,7 +176,7 @@ impl CStore { RequireDynamic => src.dylib.clone(), RequireStatic => src.rlib.clone(), })) - .collect(); + .collect::)>>(); libs.sort_by(|&(a, _), &(b, _)| { ordering.position_elem(&a).cmp(&ordering.position_elem(&b)) }); diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 0c46a5012994a..040d5c0e175fb 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1155,10 +1155,7 @@ impl MemoryMap { MapAddr(addr_) => { lpAddress = addr_ as LPVOID; }, MapFd(fd_) => { fd = fd_; }, MapOffset(offset_) => { offset = offset_; }, - MapNonStandardFlags(f) => { - info!("MemoryMap::new: MapNonStandardFlags used on \ - Windows: {}", f) - } + MapNonStandardFlags(..) => {} } } @@ -1256,15 +1253,15 @@ impl Drop for MemoryMap { MapVirtual => { if libc::VirtualFree(self.data as *mut c_void, 0, libc::MEM_RELEASE) == 0 { - error!("VirtualFree failed: {}", errno()); + println!("VirtualFree failed: {}", errno()); } }, MapFile(mapping) => { if libc::UnmapViewOfFile(self.data as LPCVOID) == FALSE { - error!("UnmapViewOfFile failed: {}", errno()); + println!("UnmapViewOfFile failed: {}", errno()); } if libc::CloseHandle(mapping as HANDLE) == FALSE { - error!("CloseHandle failed: {}", errno()); + println!("CloseHandle failed: {}", errno()); } } } diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 831f6c73e35f1..bc75a98e08565 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -16,15 +16,31 @@ use from_str::from_str; use io::{IoResult, Writer}; use iter::Iterator; use option::{Some, None}; +use os; use result::{Ok, Err}; use str::StrSlice; +use sync::atomics; pub use self::imp::write; -// This function is defined in this module so that the way to enable logging of -// backtraces has the word 'backtrace' in it: std::rt::backtrace. +// For now logging is turned off by default, and this function checks to see +// whether the magical environment variable is present to see if it's turned on. pub fn log_enabled() -> bool { - log_enabled!(::logging::DEBUG) + static mut ENABLED: atomics::AtomicInt = atomics::INIT_ATOMIC_INT; + unsafe { + match ENABLED.load(atomics::SeqCst) { + 1 => return false, + 2 => return true, + _ => {} + } + } + + let val = match os::getenv("RUST_BACKTRACE") { + Some(..) => 2, + None => 1, + }; + unsafe { ENABLED.store(val, atomics::SeqCst); } + val == 2 } #[cfg(target_word_size = "64")] static HEX_WIDTH: uint = 18; diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 3a06075ce4845..7f54b8b332067 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -398,6 +398,8 @@ fn begin_unwind_inner(msg: ~Any, file: &'static str, line: uint) -> ! { if backtrace::log_enabled() { let mut err = ::rt::util::Stderr; let _err = backtrace::write(&mut err); + } else { + rterrln!("run with `RUST_BACKTRACE=1` to see a backtrace"); } unsafe { intrinsics::abort() } } diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs index 924af6bfd423c..d4593318eafb5 100644 --- a/src/libsync/lib.rs +++ b/src/libsync/lib.rs @@ -21,10 +21,10 @@ html_root_url = "http://static.rust-lang.org/doc/master")]; #[feature(phase)]; -#[cfg(test)] #[phase(syntax, link)] extern crate log; - #[allow(deprecated_owned_vector)]; +#[cfg(test)] #[phase(syntax, link)] extern crate log; + pub use arc::{Arc, MutexArc, RWArc, RWWriteMode, RWReadMode, ArcCondvar, CowArc}; pub use sync::{Mutex, RWLock, Condvar, Semaphore, RWLockWriteMode, RWLockReadMode, Barrier, one, mutex}; diff --git a/src/libworkcache/lib.rs b/src/libworkcache/lib.rs index ce7557fb2aaa0..219bb38b3c830 100644 --- a/src/libworkcache/lib.rs +++ b/src/libworkcache/lib.rs @@ -15,8 +15,10 @@ #[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)]; #[allow(deprecated_owned_vector, visible_private_types)]; +#[phase(syntax, link)] extern crate log; extern crate serialize; extern crate collections; extern crate sync; diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 0e3b33a91d4dc..7252e319372e6 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -37,11 +37,11 @@ fn double() { fn runtest(me: &str) { let mut env = os::env(); - match env.iter().position(|&(ref s, _)| "RUST_LOG" == *s) { + match env.iter().position(|&(ref s, _)| "RUST_BACKTRACE" == *s) { Some(i) => { env.remove(i); } None => {} } - env.push((~"RUST_LOG", ~"std::rt::backtrace")); + env.push((~"RUST_BACKTRACE", ~"1")); // Make sure that the stack trace is printed let mut p = Process::configure(ProcessConfig { diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index ae21d53b7e01d..03617537c49bb 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -20,7 +20,7 @@ pub fn main() { } fn child(c: &Sender) { - error!("sending"); + println!("sending"); c.send(10); println!("value sent"); } 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 23c143445abe9..197032b3315d3 100644 --- a/src/test/run-pass/dead-code-one-arm-if.rs +++ b/src/test/run-pass/dead-code-one-arm-if.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - - +// ignore-test #12920 pub fn main() { if 1 == 1 { return; } println!("Paul is dead"); } diff --git a/src/test/run-pass/parse-fail.rs b/src/test/run-pass/parse-fail.rs index 45f19a30e86a0..03f4590023866 100644 --- a/src/test/run-pass/parse-fail.rs +++ b/src/test/run-pass/parse-fail.rs @@ -10,6 +10,8 @@ #[allow(unreachable_code)]; +// ignore-test #12920 + fn dont_call_me() { fail!(); println!("{}", 1); } pub fn main() { }