rustc: Remove usage of fmt!

Author: alexcrichton

src/librustc/back/link.rs

@@ -131,13 +131,13 @@ pub mod jit {
             for cratepath in r.iter() {
                 let path = cratepath.to_str();
 
-                debug!("linking: %s", path);
+                debug2!("linking: {}", path);
 
                 do path.with_c_str |buf_t| {
                     if !llvm::LLVMRustLoadCrate(manager, buf_t) {
                         llvm_err(sess, ~"Could not link");
                     }
-                    debug!("linked: %s", path);
+                    debug2!("linked: {}", path);
                 }
             }
 
@@ -303,7 +303,7 @@ pub mod write {
             for pass in sess.opts.custom_passes.iter() {
                 do pass.with_c_str |s| {
                     if !llvm::LLVMRustAddPass(mpm, s) {
-                        sess.warn(fmt!("Unknown pass %s, ignoring", *pass));
+                        sess.warn(format!("Unknown pass {}, ignoring", *pass));
                     }
                 }
             }
@@ -381,9 +381,9 @@ pub mod write {
         let prog = run::process_output(cc_prog, cc_args);
 
         if prog.status != 0 {
-            sess.err(fmt!("building with `%s` failed with code %d",
+            sess.err(format!("building with `{}` failed with code {}",
                         cc_prog, prog.status));
-            sess.note(fmt!("%s arguments: %s",
+            sess.note(format!("{} arguments: {}",
                         cc_prog, cc_args.connect(" ")));
             sess.note(str::from_utf8(prog.error + prog.output));
             sess.abort_if_errors();
@@ -554,7 +554,7 @@ pub fn build_link_meta(sess: Session,
                               dep_hashes: ~[@str],
                               pkg_id: Option<@str>) -> @str {
         fn len_and_str(s: &str) -> ~str {
-            fmt!("%u_%s", s.len(), s)
+            format!("{}_{}", s.len(), s)
         }
 
         fn len_and_str_lit(l: ast::lit) -> ~str {
@@ -599,7 +599,7 @@ pub fn build_link_meta(sess: Session,
 
     fn warn_missing(sess: Session, name: &str, default: &str) {
         if !*sess.building_library { return; }
-        sess.warn(fmt!("missing crate link meta `%s`, using `%s` as default",
+        sess.warn(format!("missing crate link meta `{}`, using `{}` as default",
                        name, default));
     }
 
@@ -612,7 +612,7 @@ pub fn build_link_meta(sess: Session,
                 // filestem that returned an @str
                 let name = session::expect(sess,
                                            output.filestem(),
-                                           || fmt!("output file name `%s` doesn't\
+                                           || format!("output file name `{}` doesn't\
                                                     appear to have a stem",
                                                    output.to_str())).to_managed();
                 if name.is_empty() {
@@ -762,7 +762,7 @@ pub fn mangle(sess: Session, ss: path,
 
     let push = |s: &str| {
         let sani = sanitize(s);
-        n.push_str(fmt!("%u%s", sani.len(), sani));
+        n.push_str(format!("{}{}", sani.len(), sani));
     };
 
     // First, connect each component with <len, name> pairs.
@@ -874,7 +874,7 @@ pub fn output_dll_filename(os: session::Os, lm: LinkMeta) -> ~str {
         session::OsAndroid => (android::DLL_PREFIX, android::DLL_SUFFIX),
         session::OsFreebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
     };
-    fmt!("%s%s-%s-%s%s", dll_prefix, lm.name, lm.extras_hash, lm.vers, dll_suffix)
+    format!("{}{}-{}-{}{}", dll_prefix, lm.name, lm.extras_hash, lm.vers, dll_suffix)
 }
 
 pub fn get_cc_prog(sess: Session) -> ~str {
@@ -890,7 +890,7 @@ pub fn get_cc_prog(sess: Session) -> ~str {
             session::OsAndroid =>
                 match &sess.opts.android_cross_path {
                     &Some(ref path) => {
-                        fmt!("%s/bin/arm-linux-androideabi-gcc", *path)
+                        format!("{}/bin/arm-linux-androideabi-gcc", *path)
                     }
                     &None => {
                         sess.fatal("need Android NDK path for linking \
@@ -915,29 +915,29 @@ pub fn link_binary(sess: Session,
 
     let output = if *sess.building_library {
         let long_libname = output_dll_filename(sess.targ_cfg.os, lm);
-        debug!("link_meta.name:  %s", lm.name);
-        debug!("long_libname: %s", long_libname);
-        debug!("out_filename: %s", out_filename.to_str());
-        debug!("dirname(out_filename): %s", out_filename.dir_path().to_str());
+        debug2!("link_meta.name:  {}", lm.name);
+        debug2!("long_libname: {}", long_libname);
+        debug2!("out_filename: {}", out_filename.to_str());
+        debug2!("dirname(out_filename): {}", out_filename.dir_path().to_str());
 
         out_filename.dir_path().push(long_libname)
     } else {
         out_filename.clone()
     };
 
-    debug!("output: %s", output.to_str());
+    debug2!("output: {}", output.to_str());
     let cc_args = link_args(sess, obj_filename, out_filename, lm);
-    debug!("%s link args: %s", cc_prog, cc_args.connect(" "));
+    debug2!("{} link args: {}", cc_prog, cc_args.connect(" "));
     if (sess.opts.debugging_opts & session::print_link_args) != 0 {
-        io::println(fmt!("%s link args: %s", cc_prog, cc_args.connect(" ")));
+        io::println(format!("{} link args: {}", cc_prog, cc_args.connect(" ")));
     }
 
     // We run 'cc' here
     let prog = run::process_output(cc_prog, cc_args);
     if 0 != prog.status {
-        sess.err(fmt!("linking with `%s` failed with code %d",
+        sess.err(format!("linking with `{}` failed with code {}",
                       cc_prog, prog.status));
-        sess.note(fmt!("%s arguments: %s",
+        sess.note(format!("{} arguments: {}",
                        cc_prog, cc_args.connect(" ")));
         sess.note(str::from_utf8(prog.error + prog.output));
         sess.abort_if_errors();
@@ -951,7 +951,7 @@ pub fn link_binary(sess: Session,
     // Remove the temporary object file if we aren't saving temps
     if !sess.opts.save_temps {
         if ! os::remove_file(obj_filename) {
-            sess.warn(fmt!("failed to delete object file `%s`",
+            sess.warn(format!("failed to delete object file `{}`",
                            obj_filename.to_str()));
         }
     }

src/librustc/back/rpath.rs

@@ -29,7 +29,7 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
         return ~[];
     }
 
-    debug!("preparing the RPATH!");
+    debug2!("preparing the RPATH!");
 
     let sysroot = sess.filesearch.sysroot();
     let output = out_filename;
@@ -49,21 +49,21 @@ fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path {
 }
 
 pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
-    rpaths.iter().map(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect()
+    rpaths.iter().map(|rpath| format!("-Wl,-rpath,{}",rpath.to_str())).collect()
 }
 
 fn get_rpaths(os: session::Os,
               sysroot: &Path,
               output: &Path,
               libs: &[Path],
               target_triple: &str) -> ~[Path] {
-    debug!("sysroot: %s", sysroot.to_str());
-    debug!("output: %s", output.to_str());
-    debug!("libs:");
+    debug2!("sysroot: {}", sysroot.to_str());
+    debug2!("output: {}", output.to_str());
+    debug2!("libs:");
     for libpath in libs.iter() {
-        debug!("    %s", libpath.to_str());
+        debug2!("    {}", libpath.to_str());
     }
-    debug!("target_triple: %s", target_triple);
+    debug2!("target_triple: {}", target_triple);
 
     // Use relative paths to the libraries. Binaries can be moved
     // as long as they maintain the relative relationship to the
@@ -78,9 +78,9 @@ fn get_rpaths(os: session::Os,
     let fallback_rpaths = ~[get_install_prefix_rpath(target_triple)];
 
     fn log_rpaths(desc: &str, rpaths: &[Path]) {
-        debug!("%s rpaths:", desc);
+        debug2!("{} rpaths:", desc);
         for rpath in rpaths.iter() {
-            debug!("    %s", rpath.to_str());
+            debug2!("    {}", rpath.to_str());
         }
     }
 
@@ -172,7 +172,7 @@ mod test {
         let res = get_install_prefix_rpath("triple");
         let d = Path(env!("CFG_PREFIX"))
             .push_rel(&Path("lib/rustc/triple/lib"));
-        debug!("test_prefix_path: %s vs. %s",
+        debug2!("test_prefix_path: {} vs. {}",
                res.to_str(),
                d.to_str());
         assert!(res.to_str().ends_with(d.to_str()));
@@ -233,7 +233,7 @@ mod test {
     #[test]
     fn test_get_absolute_rpath() {
         let res = get_absolute_rpath(&Path("lib/libstd.so"));
-        debug!("test_get_absolute_rpath: %s vs. %s",
+        debug2!("test_get_absolute_rpath: {} vs. {}",
                res.to_str(),
                os::make_absolute(&Path("lib")).to_str());
 

src/librustc/driver/driver.rs

@@ -386,33 +386,33 @@ pub fn phase_6_link_output(sess: Session,
 
 pub fn stop_after_phase_3(sess: Session) -> bool {
    if sess.opts.no_trans {
-        debug!("invoked with --no-trans, returning early from compile_input");
+        debug2!("invoked with --no-trans, returning early from compile_input");
         return true;
     }
     return false;
 }
 
 pub fn stop_after_phase_1(sess: Session) -> bool {
     if sess.opts.parse_only {
-        debug!("invoked with --parse-only, returning early from compile_input");
+        debug2!("invoked with --parse-only, returning early from compile_input");
         return true;
     }
     return false;
 }
 
 pub fn stop_after_phase_5(sess: Session) -> bool {
     if sess.opts.output_type != link::output_type_exe {
-        debug!("not building executable, returning early from compile_input");
+        debug2!("not building executable, returning early from compile_input");
         return true;
     }
 
     if sess.opts.is_static && *sess.building_library {
-        debug!("building static library, returning early from compile_input");
+        debug2!("building static library, returning early from compile_input");
         return true;
     }
 
     if sess.opts.jit {
-        debug!("running JIT, returning early from compile_input");
+        debug2!("running JIT, returning early from compile_input");
         return true;
     }
     return false;
@@ -670,7 +670,7 @@ pub fn build_session_options(binary: @str,
             let lint_name = lint_name.replace("-", "_");
             match lint_dict.find_equiv(&lint_name) {
               None => {
-                early_error(demitter, fmt!("unknown %s flag: %s",
+                early_error(demitter, format!("unknown {} flag: {}",
                                            level_name, lint_name));
               }
               Some(lint) => {
@@ -690,7 +690,7 @@ pub fn build_session_options(binary: @str,
             if name == debug_flag { this_bit = bit; break; }
         }
         if this_bit == 0u {
-            early_error(demitter, fmt!("unknown debug flag: %s", *debug_flag))
+            early_error(demitter, format!("unknown debug flag: {}", *debug_flag))
         }
         debugging_opts |= this_bit;
     }
@@ -1033,7 +1033,7 @@ pub fn build_output_filenames(input: &input,
 
 pub fn early_error(emitter: @diagnostic::Emitter, msg: ~str) -> ! {
     emitter.emit(None, msg, diagnostic::fatal);
-    fail!();
+    fail2!();
 }
 
 pub fn list_metadata(sess: Session, path: &Path, out: @io::Writer) {
@@ -1058,7 +1058,7 @@ mod test {
         let matches =
             &match getopts([~"--test"], optgroups()) {
               Ok(m) => m,
-              Err(f) => fail!("test_switch_implies_cfg_test: %s", f.to_err_msg())
+              Err(f) => fail2!("test_switch_implies_cfg_test: {}", f.to_err_msg())
             };
         let sessopts = build_session_options(
             @"rustc",
@@ -1079,7 +1079,8 @@ mod test {
             &match getopts([~"--test", ~"--cfg=test"], optgroups()) {
               Ok(m) => m,
               Err(f) => {
-                fail!("test_switch_implies_cfg_test_unless_cfg_test: %s", f.to_err_msg());
+                fail2!("test_switch_implies_cfg_test_unless_cfg_test: {}",
+                       f.to_err_msg());
               }
             };
         let sessopts = build_session_options(

src/librustc/driver/session.rs

@@ -296,7 +296,7 @@ impl Session_ {
     // This exists to help with refactoring to eliminate impossible
     // cases later on
     pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
-        self.span_bug(sp, fmt!("Impossible case reached: %s", msg));
+        self.span_bug(sp, format!("Impossible case reached: {}", msg));
     }
     pub fn verbose(&self) -> bool { self.debugging_opt(verbose) }
     pub fn time_passes(&self) -> bool { self.debugging_opt(time_passes) }

src/librustc/front/test.rs

@@ -78,7 +78,7 @@ impl fold::ast_fold for TestHarnessGenerator {
 
     fn fold_item(&self, i: @ast::item) -> Option<@ast::item> {
         self.cx.path.push(i.ident);
-        debug!("current path: %s",
+        debug2!("current path: {}",
                ast_util::path_name_i(self.cx.path.clone()));
 
         if is_test_fn(self.cx, i) || is_bench_fn(i) {
@@ -91,7 +91,7 @@ impl fold::ast_fold for TestHarnessGenerator {
                                      tests");
                 }
                 _ => {
-                    debug!("this is a test function");
+                    debug2!("this is a test function");
                     let test = Test {
                         span: i.span,
                         path: self.cx.path.clone(),
@@ -100,7 +100,7 @@ impl fold::ast_fold for TestHarnessGenerator {
                         should_fail: should_fail(i)
                     };
                     self.cx.testfns.push(test);
-                    // debug!("have %u test/bench functions",
+                    // debug2!("have {} test/bench functions",
                     //        cx.testfns.len());
                 }
             }
@@ -327,7 +327,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
         span: dummy_sp(),
      };
 
-    debug!("Synthetic test module:\n%s\n",
+    debug2!("Synthetic test module:\n{}\n",
            pprust::item_to_str(@item.clone(), cx.sess.intr()));
 
     return @item;
@@ -381,7 +381,7 @@ fn is_extra(crate: &ast::Crate) -> bool {
 }
 
 fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
-    debug!("building test vector from %u tests", cx.testfns.len());
+    debug2!("building test vector from {} tests", cx.testfns.len());
     let mut descs = ~[];
     for test in cx.testfns.iter() {
         descs.push(mk_test_desc_and_fn_rec(cx, test));
@@ -404,7 +404,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
     let span = test.span;
     let path = test.path.clone();
 
-    debug!("encoding %s", ast_util::path_name_i(path));
+    debug2!("encoding {}", ast_util::path_name_i(path));
 
     let name_lit: ast::lit =
         nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));