---

yaml
---
r: 83493
b: refs/heads/try
c: 1434b4b
h: refs/heads/master
i:
  83491: 3f7e8ed
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 409182de6d74889134209e7fc98174eb8f267170
+refs/heads/try: 1434b4bfcafe90cffa6627e3be18a9e5b6501ad1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/base64.rs

@@ -68,7 +68,7 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * fn main () {
      *     let str = [52,32].to_base64(standard);
-     *     println!("{}", str);
+     *     printfln!("%s", str);
      * }
      * ```
      */
@@ -177,11 +177,11 @@ impl<'self> FromBase64 for &'self str {
      *
      * fn main () {
      *     let hello_str = "Hello, World".to_base64(standard);
-     *     println!("{}", hello_str);
+     *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_base64();
-     *     println!("{:?}", bytes);
+     *     printfln!("%?", bytes);
      *     let result_str = str::from_utf8(bytes);
-     *     println!("{}", result_str);
+     *     printfln!("%s", result_str);
      * }
      * ```
      */

branches/try/src/libextra/future.rs

@@ -19,7 +19,7 @@
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
  * make_a_sandwich();
- * println!("fib(5000) = {}", delayed_fib.get())
+ * printfln!("fib(5000) = %?", delayed_fib.get())
  * ```
  */
 

branches/try/src/libextra/getopts.rs

@@ -43,7 +43,7 @@
 //! }
 //!
 //! fn print_usage(program: &str, _opts: &[Opt]) {
-//!     println!("Usage: {} [options]", program);
+//!     printfln!("Usage: %s [options]", program);
 //!     println("-o\t\tOutput");
 //!     println("-h --help\tUsage");
 //! }

branches/try/src/libextra/hex.rs

@@ -33,7 +33,7 @@ impl<'self> ToHex for &'self [u8] {
      *
      * fn main () {
      *     let str = [52,32].to_hex();
-     *     println!("{}", str);
+     *     printfln!("%s", str);
      * }
      * ```
      */
@@ -77,11 +77,11 @@ impl<'self> FromHex for &'self str {
      *
      * fn main () {
      *     let hello_str = "Hello, World".to_hex();
-     *     println!("{}", hello_str);
+     *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_hex().unwrap();
-     *     println!("{:?}", bytes);
+     *     printfln!("%?", bytes);
      *     let result_str = str::from_utf8(bytes);
-     *     println!("{}", result_str);
+     *     printfln!("%s", result_str);
      * }
      * ```
      */

branches/try/src/libextra/task_pool.rs

@@ -103,6 +103,6 @@ fn test_task_pool() {
     };
     let mut pool = TaskPool::new(4, Some(SingleThreaded), f);
     do 8.times {
-        pool.execute(|i| println!("Hello from thread {}!", *i));
+        pool.execute(|i| printfln!("Hello from thread %u!", *i));
     }
 }

branches/try/src/librust/rust.rs

@@ -136,13 +136,13 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
         match find_cmd(command_string) {
             Some(command) => {
                 match command.action {
-                    CallMain(prog, _) => println!(
-                        "The {} command is an alias for the {} program.",
+                    CallMain(prog, _) => printfln!(
+                        "The %s command is an alias for the %s program.",
                         command.cmd, prog),
                     _       => ()
                 }
                 match command.usage_full {
-                    UsgStr(msg) => println!("{}\n", msg),
+                    UsgStr(msg) => printfln!("%s\n", msg),
                     UsgCall(f)  => f(),
                 }
                 Valid(0)
@@ -215,7 +215,7 @@ fn usage() {
 
     for command in COMMANDS.iter() {
         let padding = " ".repeat(INDENT - command.cmd.len());
-        println!("    {}{}{}", command.cmd, padding, command.usage_line);
+        printfln!("    %s%s%s", command.cmd, padding, command.usage_line);
     }
 
     io::print(

branches/try/src/librustc/metadata/encoder.rs

@@ -1822,17 +1822,17 @@ pub fn encode_metadata(parms: EncodeParams, crate: &Crate) -> ~[u8] {
         }
 
         io::println("metadata stats:");
-        println!("    inline bytes: {}", ecx.stats.inline_bytes);
-        println!(" attribute bytes: {}", ecx.stats.attr_bytes);
-        println!("       dep bytes: {}", ecx.stats.dep_bytes);
-        println!(" lang item bytes: {}", ecx.stats.lang_item_bytes);
-        println!(" link args bytes: {}", ecx.stats.link_args_bytes);
-        println!("      impl bytes: {}", ecx.stats.impl_bytes);
-        println!("      misc bytes: {}", ecx.stats.misc_bytes);
-        println!("      item bytes: {}", ecx.stats.item_bytes);
-        println!("     index bytes: {}", ecx.stats.index_bytes);
-        println!("      zero bytes: {}", ecx.stats.zero_bytes);
-        println!("     total bytes: {}", ecx.stats.total_bytes);
+        printfln!("    inline bytes: %u", ecx.stats.inline_bytes);
+        printfln!(" attribute bytes: %u", ecx.stats.attr_bytes);
+        printfln!("       dep bytes: %u", ecx.stats.dep_bytes);
+        printfln!(" lang item bytes: %u", ecx.stats.lang_item_bytes);
+        printfln!(" link args bytes: %u", ecx.stats.link_args_bytes);
+        printfln!("      impl bytes: %u", ecx.stats.impl_bytes);
+        printfln!("      misc bytes: %u", ecx.stats.misc_bytes);
+        printfln!("      item bytes: %u", ecx.stats.item_bytes);
+        printfln!("     index bytes: %u", ecx.stats.index_bytes);
+        printfln!("      zero bytes: %u", ecx.stats.zero_bytes);
+        printfln!("     total bytes: %u", ecx.stats.total_bytes);
     }
 
     // Pad this, since something (LLVM, presumably) is cutting off the

branches/try/src/librustc/middle/borrowck/mod.rs

@@ -100,16 +100,16 @@ pub fn check_crate(
 
     if tcx.sess.borrowck_stats() {
         io::println("--- borrowck stats ---");
-        println!("paths requiring guarantees: {}",
-                 bccx.stats.guaranteed_paths);
-        println!("paths requiring loans     : {}",
-                 make_stat(bccx, bccx.stats.loaned_paths_same));
-        println!("paths requiring imm loans : {}",
-                 make_stat(bccx, bccx.stats.loaned_paths_imm));
-        println!("stable paths              : {}",
-                 make_stat(bccx, bccx.stats.stable_paths));
-        println!("paths requiring purity    : {}",
-                 make_stat(bccx, bccx.stats.req_pure_paths));
+        printfln!("paths requiring guarantees: %u",
+                  bccx.stats.guaranteed_paths);
+        printfln!("paths requiring loans     : %s",
+                  make_stat(bccx, bccx.stats.loaned_paths_same));
+        printfln!("paths requiring imm loans : %s",
+                  make_stat(bccx, bccx.stats.loaned_paths_imm));
+        printfln!("stable paths              : %s",
+                  make_stat(bccx, bccx.stats.stable_paths));
+        printfln!("paths requiring purity    : %s",
+                  make_stat(bccx, bccx.stats.req_pure_paths));
     }
 
     return (bccx.root_map, bccx.write_guard_map);

branches/try/src/librustc/middle/trans/base.rs

@@ -121,7 +121,7 @@ impl Drop for _InsnCtxt {
 }
 
 pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
-    debug2!("new InsnCtxt: {}", s);
+    debug!("new InsnCtxt: %s", s);
     do local_data::modify(task_local_insn_key) |c| {
         do c.map_move |ctx| {
             let mut ctx = (*ctx).clone();
@@ -3156,30 +3156,30 @@ pub fn trans_crate(sess: session::Session,
     write_metadata(ccx, crate);
     if ccx.sess.trans_stats() {
         io::println("--- trans stats ---");
-        println!("n_static_tydescs: {}", ccx.stats.n_static_tydescs);
-        println!("n_glues_created: {}", ccx.stats.n_glues_created);
-        println!("n_null_glues: {}", ccx.stats.n_null_glues);
-        println!("n_real_glues: {}", ccx.stats.n_real_glues);
-
-        println!("n_fns: {}", ccx.stats.n_fns);
-        println!("n_monos: {}", ccx.stats.n_monos);
-        println!("n_inlines: {}", ccx.stats.n_inlines);
-        println!("n_closures: {}", ccx.stats.n_closures);
+        printfln!("n_static_tydescs: %u", ccx.stats.n_static_tydescs);
+        printfln!("n_glues_created: %u", ccx.stats.n_glues_created);
+        printfln!("n_null_glues: %u", ccx.stats.n_null_glues);
+        printfln!("n_real_glues: %u", ccx.stats.n_real_glues);
+
+        printfln!("n_fns: %u", ccx.stats.n_fns);
+        printfln!("n_monos: %u", ccx.stats.n_monos);
+        printfln!("n_inlines: %u", ccx.stats.n_inlines);
+        printfln!("n_closures: %u", ccx.stats.n_closures);
         io::println("fn stats:");
         do sort::quick_sort(ccx.stats.fn_stats) |&(_, _, insns_a), &(_, _, insns_b)| {
             insns_a > insns_b
         }
         for tuple in ccx.stats.fn_stats.iter() {
             match *tuple {
                 (ref name, ms, insns) => {
-                    println!("{} insns, {} ms, {}", insns, ms, *name);
+                    printfln!("%u insns, %u ms, %s", insns, ms, *name);
                 }
             }
         }
     }
     if ccx.sess.count_llvm_insns() {
         for (k, v) in ccx.stats.llvm_insns.iter() {
-            println!("{:7u} {}", *v, *k);
+            printfln!("%-7u %s", *v, *k);
         }
     }
 

branches/try/src/librustc/middle/trans/controlflow.rs

@@ -25,6 +25,7 @@ use syntax::ast;
 use syntax::ast::Name;
 use syntax::ast_util;
 use syntax::codemap::Span;
+use syntax::visit::Visitor;
 
 pub fn trans_block(bcx: @mut Block, b: &ast::Block, dest: expr::Dest) -> @mut Block {
     let _icx = push_ctxt("trans_block");
@@ -64,12 +65,22 @@ pub fn trans_if(bcx: @mut Block,
     // Drop branches that are known to be impossible
     if is_const(cond_val) && !is_undef(cond_val) {
         if const_to_uint(cond_val) == 1 {
+            match els {
+                Some(elexpr) => {
+                    let mut trans = TransItemVisitor { ccx: bcx.fcx.ccx };
+                    trans.visit_expr(elexpr, ());
+                }
+                None => {}
+            }
             // if true { .. } [else { .. }]
             return do with_scope(bcx, thn.info(), "if_true_then") |bcx| {
                 let bcx_out = trans_block(bcx, thn, dest);
                 trans_block_cleanups(bcx_out, block_cleanups(bcx))
             }
         } else {
+            let mut trans = TransItemVisitor { ccx: bcx.fcx.ccx } ;
+            trans.visit_block(thn, ());
+
             match els {
                 // if false { .. } else { .. }
                 Some(elexpr) => {

branches/try/src/librustc/middle/trans/glue.rs

@@ -646,8 +646,8 @@ pub fn declare_tydesc(ccx: &mut CrateContext, t: ty::t) -> @mut tydesc_info {
     let llty = type_of(ccx, t);
 
     if ccx.sess.count_type_sizes() {
-        println!("{}\t{}", llsize_of_real(ccx, llty),
-                 ppaux::ty_to_str(ccx.tcx, t));
+        printfln!("%u\t%s", llsize_of_real(ccx, llty),
+                  ppaux::ty_to_str(ccx.tcx, t));
     }
 
     let has_header = match ty::get(t).sty {

branches/try/src/librustc/rustc.rs

@@ -130,13 +130,13 @@ pub fn version(argv0: &str) {
         Some(vers) => vers,
         None => "unknown version"
     };
-    println!("{} {}", argv0, vers);
-    println!("host: {}", host_triple());
+    printfln!("%s %s", argv0, vers);
+    printfln!("host: %s", host_triple());
 }
 
 pub fn usage(argv0: &str) {
     let message = fmt!("Usage: %s [OPTIONS] INPUT", argv0);
-    println!("{}\n\
+    printfln!("%s\n\
 Additional help:
     -W help             Print 'lint' options and default settings
     -Z help             Print internal options for debugging rustc\n",
@@ -167,16 +167,16 @@ Available lint options:
         str::from_utf8(vec::from_elem(max - s.len(), ' ' as u8)) + s
     }
     println("\nAvailable lint checks:\n");
-    println!("    {}  {:7.7s}  {}",
-             padded(max_key, "name"), "default", "meaning");
-    println!("    {}  {:7.7s}  {}\n",
-             padded(max_key, "----"), "-------", "-------");
+    printfln!("    %s  %7.7s  %s",
+              padded(max_key, "name"), "default", "meaning");
+    printfln!("    %s  %7.7s  %s\n",
+              padded(max_key, "----"), "-------", "-------");
     for (spec, name) in lint_dict.move_iter() {
         let name = name.replace("_", "-");
-        println!("    {}  {:7.7s}  {}",
-                 padded(max_key, name),
-                 lint::level_to_str(spec.default),
-                 spec.desc);
+        printfln!("    %s  %7.7s  %s",
+                  padded(max_key, name),
+                  lint::level_to_str(spec.default),
+                  spec.desc);
     }
     io::println("");
 }
@@ -187,7 +187,7 @@ pub fn describe_debug_flags() {
     for tuple in r.iter() {
         match *tuple {
             (ref name, ref desc, _) => {
-                println!("    -Z {:>20s} -- {}", *name, *desc);
+                printfln!("    -Z %-20s -- %s", *name, *desc);
             }
         }
     }

branches/try/src/librustc/util/common.rs

@@ -22,7 +22,7 @@ pub fn time<T>(do_it: bool, what: ~str, thunk: &fn() -> T) -> T {
     let start = extra::time::precise_time_s();
     let rv = thunk();
     let end = extra::time::precise_time_s();
-    println!("time: {:3.3f} s\t{}", end - start, what);
+    printfln!("time: %3.3f s\t%s", end - start, what);
     rv
 }
 

branches/try/src/librusti/rusti.rs

@@ -437,7 +437,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
             if loaded_crates.is_empty() {
                 println("no crates loaded");
             } else {
-                println!("crates loaded: {}", loaded_crates.connect(", "));
+                printfln!("crates loaded: %s", loaded_crates.connect(", "));
             }
         }
         ~"{" => {

branches/try/src/librustpkg/testsuite/pass/src/fancy-lib/pkg.rs

@@ -34,7 +34,7 @@ pub fn main() {
     }
 
     if args[2] != ~"install" {
-        println!("Warning: I don't know how to {}", args[2]);
+        printfln!("Warning: I don't know how to %s", args[2]);
         return;
     }
 

branches/try/src/libstd/iter.rs

@@ -413,7 +413,7 @@ pub trait Iterator<A> {
     /// use std::iter::count;
     ///
     /// for i in count(0, 10) {
-    ///     println!("{}", i);
+    ///     printfln!("%d", i);
     /// }
     /// ```
     #[inline]

branches/try/src/libstd/logging.rs

@@ -10,11 +10,11 @@
 
 //! Logging
 
+use fmt;
 use option::*;
 use os;
 use rt;
 use rt::logging::{Logger, StdErrLogger};
-use send_str::SendStrOwned;
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -37,7 +37,17 @@ pub fn console_off() {
     rt::logging::console_off();
 }
 
-fn newsched_log_str(msg: ~str) {
+#[cfg(stage0)]
+#[doc(hidden)]
+pub fn log(_level: u32, s: ~str) {
+    // this is a terrible approximation, but it gets the job done (for stage0 at
+    // least)
+    ::io::println(s);
+}
+
+#[allow(missing_doc)]
+#[cfg(not(stage0))]
+pub fn log(_level: u32, args: &fmt::Arguments) {
     use rt::task::Task;
     use rt::local::Local;
 
@@ -46,20 +56,13 @@ fn newsched_log_str(msg: ~str) {
         match optional_task {
             Some(local) => {
                 // Use the available logger
-                (*local).logger.log(SendStrOwned(msg));
+                (*local).logger.log(args);
             }
             None => {
                 // There is no logger anywhere, just write to stderr
                 let mut logger = StdErrLogger;
-                logger.log(SendStrOwned(msg));
+                logger.log(args);
             }
         }
     }
 }
-
-// XXX: This will change soon to not require an allocation. This is an unstable
-//      api which should not be used outside of the macros in ext/expand.
-#[doc(hidden)]
-pub fn log(_level: u32, msg: ~str) {
-    newsched_log_str(msg);
-}