rpass: Remove usage of fmt!

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -91,7 +91,7 @@ pub fn parse_config(args: ~[~str]) -> config {
     let matches =
         &match getopts::groups::getopts(args_, groups) {
           Ok(m) => m,
-          Err(f) => fail2!(f.to_err_msg())
+          Err(f) => fail2!("{}", f.to_err_msg())
         };
 
     if matches.opt_present("h") || matches.opt_present("help") {

src/test/auxiliary/cci_class_4.rs

@@ -21,19 +21,19 @@ pub mod kitties {
 
         pub fn eat(&mut self) -> bool {
             if self.how_hungry > 0 {
-                error!("OM NOM NOM");
+                error2!("OM NOM NOM");
                 self.how_hungry -= 2;
                 return true;
             } else {
-                error!("Not hungry!");
+                error2!("Not hungry!");
                 return false;
             }
         }
     }
 
     impl cat {
         pub fn meow(&mut self) {
-            error!("Meow");
+            error2!("Meow");
             self.meows += 1u;
             if self.meows % 5u == 0u {
                 self.how_hungry += 1;

src/test/auxiliary/cci_class_cast.rs

@@ -21,7 +21,7 @@ pub mod kitty {
 
     impl cat {
         fn meow(&mut self) {
-            error!("Meow");
+            error2!("Meow");
             self.meows += 1u;
             if self.meows % 5u == 0u {
                 self.how_hungry += 1;
@@ -35,12 +35,12 @@ pub mod kitty {
 
         pub fn eat(&mut self) -> bool {
             if self.how_hungry > 0 {
-                error!("OM NOM NOM");
+                error2!("OM NOM NOM");
                 self.how_hungry -= 2;
                 return true;
             }
             else {
-                error!("Not hungry!");
+                error2!("Not hungry!");
                 return false;
             }
         }

src/test/auxiliary/cci_nested_lib.rs

@@ -33,7 +33,7 @@ pub fn alist_get<A:Clone + 'static,
             return entry.value.clone();
         }
     }
-    fail!();
+    fail2!();
 }
 
 #[inline]

src/test/auxiliary/extern-crosscrate-source.rs

@@ -28,7 +28,7 @@ pub mod rustrt {
 #[fixed_stack_segment] #[inline(never)]
 pub fn fact(n: uint) -> uint {
     unsafe {
-        info!("n = %?", n);
+        info2!("n = {}", n);
         rustrt::rust_dbg_call(cb, n)
     }
 }

src/test/auxiliary/issue2378a.rs

@@ -17,7 +17,7 @@ impl <T:Clone> Index<uint,T> for maybe<T> {
     fn index(&self, _idx: &uint) -> T {
         match self {
             &just(ref t) => (*t).clone(),
-            &nothing => { fail!(); }
+            &nothing => { fail2!(); }
         }
     }
 }

src/test/auxiliary/issue_2723_a.rs

@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub unsafe fn f(xs: ~[int]) {
-    xs.map(|_x| { unsafe fn q() { fail!(); } });
+    xs.map(|_x| { unsafe fn q() { fail2!(); } });
 }

src/test/auxiliary/static-methods-crate.rs

@@ -38,6 +38,6 @@ impl read for bool {
 pub fn read<T:read>(s: ~str) -> T {
     match read::readMaybe(s) {
       Some(x) => x,
-      _ => fail!("read failed!")
+      _ => fail2!("read failed!")
     }
 }

src/test/run-pass/alignment-gep-tup-like-1.rs

@@ -36,7 +36,7 @@ fn f<A:Clone + 'static>(a: A, b: u16) -> @Invokable<A> {
 
 pub fn main() {
     let (a, b) = f(22_u64, 44u16).f();
-    info!("a=%? b=%?", a, b);
+    info2!("a={:?} b={:?}", a, b);
     assert_eq!(a, 22u64);
     assert_eq!(b, 44u16);
 }

src/test/run-pass/alignment-gep-tup-like-2.rs

@@ -55,7 +55,7 @@ pub fn main() {
     let z = f(~x, y);
     make_cycle(z);
     let (a, b) = z.f();
-    info!("a=%u b=%u", *a as uint, b as uint);
+    info2!("a={} b={}", *a as uint, b as uint);
     assert_eq!(*a, x);
     assert_eq!(b, y);
 }

src/test/run-pass/arith-0.rs

@@ -12,6 +12,6 @@
 
 pub fn main() {
     let a: int = 10;
-    info!(a);
+    info2!("{}", a);
     assert_eq!(a * (a - 1), 90);
 }

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);
+    info2!("{}", i32_b | i32_b << 1);
     assert_eq!(i32_b | i32_b << 1, 0x30303030);
 }

src/test/run-pass/attr-main-2.rs

@@ -11,7 +11,7 @@
 // xfail-fast
 
 pub fn main() {
-    fail!()
+    fail2!()
 }
 
 #[main]

src/test/run-pass/auto-instantiate.rs

@@ -19,6 +19,6 @@ struct Triple { x: int, y: int, z: int }
 fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
 
 pub fn main() {
-    info!("%?", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
-    info!("%?", f(5, 6).a);
+    info2!("{:?}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
+    info2!("{:?}", f(5, 6).a);
 }

src/test/run-pass/autoref-intermediate-types-issue-3585.rs

@@ -14,13 +14,13 @@ trait Foo {
 
 impl<T:Foo> Foo for @T {
     fn foo(&self) -> ~str {
-        fmt!("@%s", (**self).foo())
+        format!("@{}", (**self).foo())
     }
 }
 
 impl Foo for uint {
     fn foo(&self) -> ~str {
-        fmt!("%u", *self)
+        format!("{}", *self)
     }
 }
 

src/test/run-pass/binary-minus-without-space.rs

@@ -11,6 +11,6 @@
 // Check that issue #954 stays fixed
 
 pub fn main() {
-    match -1 { -1 => {}, _ => fail!("wat") }
+    match -1 { -1 => {}, _ => fail2!("wat") }
     assert_eq!(1-1, 0);
 }

src/test/run-pass/bind-by-move.rs

@@ -18,6 +18,6 @@ pub fn main() {
     let x = Some(p);
     match x {
         Some(z) => { dispose(z); },
-        None => fail!()
+        None => fail2!()
     }
 }

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",
+  error2!("q = {:x}, r = {:x}",
          (::std::cast::transmute::<*p, uint>(&q)),
          (::std::cast::transmute::<*p, uint>(&r)));
   }

src/test/run-pass/bitwise.rs

@@ -27,8 +27,8 @@ fn general() {
     a ^= b;
     b ^= a;
     a = a ^ b;
-    info!(a);
-    info!(b);
+    info2!("{}", a);
+    info2!("{}", b);
     assert_eq!(b, 1);
     assert_eq!(a, 2);
     assert_eq!(!0xf0 & 0xff, 0xf);

src/test/run-pass/block-arg.rs

@@ -14,7 +14,7 @@ pub fn main() {
 
     // Statement form does not require parentheses:
     for i in v.iter() {
-        info!("%?", *i);
+        info2!("{:?}", *i);
     }
 
     // Usable at all:
@@ -35,14 +35,14 @@ pub fn main() {
         assert!(false);
     }
     match do v.iter().all |e| { e.is_negative() } {
-        true => { fail!("incorrect answer."); }
+        true => { fail2!("incorrect answer."); }
         false => { }
     }
     match 3 {
       _ if do v.iter().any |e| { e.is_negative() } => {
       }
       _ => {
-        fail!("wrong answer.");
+        fail2!("wrong answer.");
       }
     }
 

src/test/run-pass/block-explicit-types.rs

@@ -10,5 +10,5 @@
 
 pub fn main() {
     fn as_buf<T>(s: ~str, f: &fn(~str) -> T) -> T { f(s) }
-    as_buf(~"foo", |foo: ~str| -> () error!(foo) );
+    as_buf(~"foo", |foo: ~str| -> () error2!("{}", foo) );
 }

src/test/run-pass/block-iter-1.rs

@@ -20,6 +20,6 @@ pub fn main() {
             odds += 1;
         }
     });
-    error!(odds);
+    error2!("{:?}", odds);
     assert_eq!(odds, 4);
 }

src/test/run-pass/block-iter-2.rs

@@ -20,6 +20,6 @@ pub fn main() {
             sum += *i * *j;
         });
     });
-    error!(sum);
+    error2!("{:?}", sum);
     assert_eq!(sum, 225);
 }

src/test/run-pass/borrowck-macro-interaction-issue-6304.rs

@@ -19,11 +19,11 @@ impl Foo {
     );
     match s {
       ~Bar2(id, rest) => declare!(id, self.elaborate_stm(rest)),
-      _ => fail!()
+      _ => fail2!()
     }
   }
 
-  fn check_id(&mut self, s: int) { fail!() }
+  fn check_id(&mut self, s: int) { fail2!() }
 }
- 
+
 pub fn main() { }

src/test/run-pass/borrowck-mut-uniq.rs

@@ -31,9 +31,9 @@ pub fn main() {
     add_int(ints, 44);
 
     do iter_ints(ints) |i| {
-        error!("int = %d", *i);
+        error2!("int = {}", *i);
         true
     };
 
-    error!("ints=%?", ints);
+    error2!("ints={:?}", ints);
 }

src/test/run-pass/borrowck-preserve-box-in-discr.rs

@@ -23,7 +23,7 @@ pub fn main() {
 
         x = @F {f: ~4};
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(**b_x)) as uint);
         assert_eq!(**b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(**b_x)));

src/test/run-pass/borrowck-preserve-box-in-field.rs

@@ -28,7 +28,7 @@ pub fn main() {
         assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x)));
         x = @F {f: ~4};
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(*b_x)) as uint);
         assert_eq!(*b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x)));

src/test/run-pass/borrowck-preserve-box-in-pat.rs

@@ -23,7 +23,7 @@ pub fn main() {
 
         *x = @F {f: ~4};
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(**b_x)) as uint);
         assert_eq!(**b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(**b_x)));

src/test/run-pass/borrowck-preserve-box-in-uniq.rs

@@ -28,7 +28,7 @@ pub fn main() {
         assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x)));
         *x = @F{f: ~4};
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(*b_x)) as uint);
         assert_eq!(*b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x)));

src/test/run-pass/borrowck-preserve-box.rs

@@ -26,7 +26,7 @@ pub fn main() {
         assert_eq!(ptr::to_unsafe_ptr(&(*x)), ptr::to_unsafe_ptr(&(*b_x)));
         x = @22;
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(*b_x)) as uint);
         assert_eq!(*b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x)) != ptr::to_unsafe_ptr(&(*b_x)));

src/test/run-pass/borrowck-preserve-cond-box.rs

@@ -25,13 +25,13 @@ fn testfn(cond: bool) {
         exp = 4;
     }
 
-    info!("*r = %d, exp = %d", *r, exp);
+    info2!("*r = {}, exp = {}", *r, exp);
     assert_eq!(*r, exp);
 
     x = @5;
     y = @6;
 
-    info!("*r = %d, exp = %d", *r, exp);
+    info2!("*r = {}, exp = {}", *r, exp);
     assert_eq!(*r, exp);
     assert_eq!(x, @5);
     assert_eq!(y, @6);

src/test/run-pass/borrowck-preserve-expl-deref.rs

@@ -28,7 +28,7 @@ pub fn main() {
         assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x)));
         x = @F {f: ~4};
 
-        info!("ptr::to_unsafe_ptr(*b_x) = %x",
+        info2!("ptr::to_unsafe_ptr(*b_x) = {:x}",
                ptr::to_unsafe_ptr(&(*b_x)) as uint);
         assert_eq!(*b_x, 3);
         assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x)));

src/test/run-pass/borrowck-unary-move-2.rs

@@ -14,7 +14,7 @@ struct noncopyable {
 
 impl Drop for noncopyable {
     fn drop(&mut self) {
-        error!("dropped");
+        error2!("dropped");
     }
 }
 

src/test/run-pass/box-inside-if.rs

@@ -19,7 +19,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)) { error2!("bloop"); }
 }
 
 pub fn main() { foo(67, 5); }

src/test/run-pass/box-inside-if2.rs

@@ -19,7 +19,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)) { error2!("bloop"); }
 }
 
 pub fn main() { foo(67, 5); }

src/test/run-pass/box-unbox.rs

@@ -17,6 +17,6 @@ fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); }
 pub fn main() {
     let foo: int = 17;
     let bfoo: Box<int> = Box {c: @foo};
-    info!("see what's in our box");
+    info2!("see what's in our box");
     assert_eq!(unbox::<int>(bfoo), foo);
 }

src/test/run-pass/boxed-class-type-substitution.rs

@@ -15,7 +15,7 @@ struct Tree<T> {
     parent: Option<T>
 }
 
-fn empty<T>() -> Tree<T> { fail!() }
+fn empty<T>() -> Tree<T> { fail2!() }
 
 struct Box {
     tree: Tree<@Box>