std: Remove usage of fmt!

Author: alexcrichton

src/libstd/at_vec.rs

@@ -236,7 +236,7 @@ pub mod raw {
                 let alloc = n * (*ty).size;
                 let total_size = alloc + sys::size_of::<Vec<()>>();
                 if alloc / (*ty).size != n || total_size < alloc {
-                    fail!("vector size is too large: %u", n);
+                    fail2!("vector size is too large: {}", n);
                 }
                 (*ptr) = local_realloc(*ptr as *(), total_size) as *mut Box<Vec<()>>;
                 (**ptr).data.alloc = alloc;

src/libstd/c_str.rs

@@ -116,7 +116,7 @@ impl CString {
     ///
     /// Fails if the CString is null.
     pub fn with_ref<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
-        if self.buf.is_null() { fail!("CString is null!"); }
+        if self.buf.is_null() { fail2!("CString is null!"); }
         f(self.buf)
     }
 
@@ -126,7 +126,7 @@ impl CString {
     ///
     /// Fails if the CString is null.
     pub fn with_mut_ref<T>(&mut self, f: &fn(*mut libc::c_char) -> T) -> T {
-        if self.buf.is_null() { fail!("CString is null!"); }
+        if self.buf.is_null() { fail2!("CString is null!"); }
         f(unsafe { cast::transmute_mut_unsafe(self.buf) })
     }
 
@@ -152,7 +152,7 @@ impl CString {
     /// Fails if the CString is null.
     #[inline]
     pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
-        if self.buf.is_null() { fail!("CString is null!"); }
+        if self.buf.is_null() { fail2!("CString is null!"); }
         unsafe {
             cast::transmute((self.buf, self.len() + 1))
         }
@@ -273,7 +273,7 @@ impl<'self> ToCStr for &'self [u8] {
         do self.as_imm_buf |self_buf, self_len| {
             let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
             if buf.is_null() {
-                fail!("failed to allocate memory!");
+                fail2!("failed to allocate memory!");
             }
 
             ptr::copy_memory(buf, self_buf, self_len);

src/libstd/cell.rs

@@ -44,7 +44,7 @@ impl<T> Cell<T> {
     pub fn take(&self) -> T {
         let this = unsafe { transmute_mut(self) };
         if this.is_empty() {
-            fail!("attempt to take an empty cell");
+            fail2!("attempt to take an empty cell");
         }
 
         this.value.take_unwrap()
@@ -60,7 +60,7 @@ impl<T> Cell<T> {
     pub fn put_back(&self, value: T) {
         let this = unsafe { transmute_mut(self) };
         if !this.is_empty() {
-            fail!("attempt to put a value back into a full cell");
+            fail2!("attempt to put a value back into a full cell");
         }
         this.value = Some(value);
     }

src/libstd/char.rs

@@ -187,7 +187,7 @@ pub fn is_digit_radix(c: char, radix: uint) -> bool {
 #[inline]
 pub fn to_digit(c: char, radix: uint) -> Option<uint> {
     if radix > 36 {
-        fail!("to_digit: radix %? is to high (maximum 36)", radix);
+        fail2!("to_digit: radix {} is to high (maximum 36)", radix);
     }
     let val = match c {
       '0' .. '9' => c as uint - ('0' as uint),
@@ -214,7 +214,7 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
 #[inline]
 pub fn from_digit(num: uint, radix: uint) -> Option<char> {
     if radix > 36 {
-        fail!("from_digit: radix %? is to high (maximum 36)", num);
+        fail2!("from_digit: radix {} is to high (maximum 36)", num);
     }
     if num < radix {
         unsafe {
@@ -342,7 +342,7 @@ pub fn len_utf8_bytes(c: char) -> uint {
         _ if code < MAX_TWO_B   => 2u,
         _ if code < MAX_THREE_B => 3u,
         _ if code < MAX_FOUR_B  => 4u,
-        _                       => fail!("invalid character!"),
+        _                       => fail2!("invalid character!"),
     }
 }
 

src/libstd/condition.rs

@@ -56,7 +56,7 @@ do my_error::cond.trap(|raised_int| {
 Condition handling is useful in cases where propagating errors is either to
 cumbersome or just not necessary in the first place. It should also be noted,
 though, that if there is not handler installed when a condition is raised, then
-the task invokes `fail!()` and will terminate.
+the task invokes `fail2!()` and will terminate.
 
 ## More Info
 
@@ -127,20 +127,20 @@ impl<T, U> Condition<T, U> {
     /// If a handler is found, its return value is returned, otherwise this
     /// function will not return.
     pub fn raise(&self, t: T) -> U {
-        let msg = fmt!("Unhandled condition: %s: %?", self.name, t);
-        self.raise_default(t, || fail!(msg.clone()))
+        let msg = format!("Unhandled condition: {}: {:?}", self.name, t);
+        self.raise_default(t, || fail2!("{}", msg.clone()))
     }
 
     /// Performs the same functionality as `raise`, except that when no handler
     /// is found the `default` argument is called instead of failing the task.
     pub fn raise_default(&self, t: T, default: &fn() -> U) -> U {
         match local_data::pop(self.key) {
             None => {
-                debug!("Condition.raise: found no handler");
+                debug2!("Condition.raise: found no handler");
                 default()
             }
             Some(handler) => {
-                debug!("Condition.raise: found handler");
+                debug2!("Condition.raise: found handler");
                 match handler.prev {
                     None => {}
                     Some(hp) => local_data::set(self.key, hp)
@@ -183,7 +183,7 @@ impl<'self, T, U> Trap<'self, T, U> {
     /// ```
     pub fn inside<V>(&self, inner: &'self fn() -> V) -> V {
         let _g = Guard { cond: self.cond };
-        debug!("Trap: pushing handler to TLS");
+        debug2!("Trap: pushing handler to TLS");
         local_data::set(self.cond.key, self.handler);
         inner()
     }
@@ -197,7 +197,7 @@ struct Guard<'self, T, U> {
 #[unsafe_destructor]
 impl<'self, T, U> Drop for Guard<'self, T, U> {
     fn drop(&mut self) {
-        debug!("Guard: popping handler from TLS");
+        debug2!("Guard: popping handler from TLS");
         let curr = local_data::pop(self.cond.key);
         match curr {
             None => {}
@@ -216,20 +216,20 @@ mod test {
     }
 
     fn trouble(i: int) {
-        debug!("trouble: raising condition");
+        debug2!("trouble: raising condition");
         let j = sadness::cond.raise(i);
-        debug!("trouble: handler recovered with %d", j);
+        debug2!("trouble: handler recovered with {}", j);
     }
 
     fn nested_trap_test_inner() {
         let mut inner_trapped = false;
 
         do sadness::cond.trap(|_j| {
-            debug!("nested_trap_test_inner: in handler");
+            debug2!("nested_trap_test_inner: in handler");
             inner_trapped = true;
             0
         }).inside {
-            debug!("nested_trap_test_inner: in protected block");
+            debug2!("nested_trap_test_inner: in protected block");
             trouble(1);
         }
 
@@ -241,10 +241,10 @@ mod test {
         let mut outer_trapped = false;
 
         do sadness::cond.trap(|_j| {
-            debug!("nested_trap_test_outer: in handler");
+            debug2!("nested_trap_test_outer: in handler");
             outer_trapped = true; 0
         }).inside {
-            debug!("nested_guard_test_outer: in protected block");
+            debug2!("nested_guard_test_outer: in protected block");
             nested_trap_test_inner();
             trouble(1);
         }
@@ -256,13 +256,13 @@ mod test {
         let mut inner_trapped = false;
 
         do sadness::cond.trap(|_j| {
-            debug!("nested_reraise_trap_test_inner: in handler");
+            debug2!("nested_reraise_trap_test_inner: in handler");
             inner_trapped = true;
             let i = 10;
-            debug!("nested_reraise_trap_test_inner: handler re-raising");
+            debug2!("nested_reraise_trap_test_inner: handler re-raising");
             sadness::cond.raise(i)
         }).inside {
-            debug!("nested_reraise_trap_test_inner: in protected block");
+            debug2!("nested_reraise_trap_test_inner: in protected block");
             trouble(1);
         }
 
@@ -274,10 +274,10 @@ mod test {
         let mut outer_trapped = false;
 
         do sadness::cond.trap(|_j| {
-            debug!("nested_reraise_trap_test_outer: in handler");
+            debug2!("nested_reraise_trap_test_outer: in handler");
             outer_trapped = true; 0
         }).inside {
-            debug!("nested_reraise_trap_test_outer: in protected block");
+            debug2!("nested_reraise_trap_test_outer: in protected block");
             nested_reraise_trap_test_inner();
         }
 
@@ -289,10 +289,10 @@ mod test {
         let mut trapped = false;
 
         do sadness::cond.trap(|j| {
-            debug!("test_default: in handler");
+            debug2!("test_default: in handler");
             sadness::cond.raise_default(j, || { trapped=true; 5 })
         }).inside {
-            debug!("test_default: in protected block");
+            debug2!("test_default: in protected block");
             trouble(1);
         }
 

src/libstd/either.rs

@@ -78,7 +78,7 @@ impl<L, R> Either<L, R> {
     pub fn expect_left(self, reason: &str) -> L {
         match self {
             Left(x) => x,
-            Right(_) => fail!(reason.to_owned())
+            Right(_) => fail2!("{}", reason.to_owned())
         }
     }
 
@@ -94,7 +94,7 @@ impl<L, R> Either<L, R> {
     pub fn expect_right(self, reason: &str) -> R {
         match self {
             Right(x) => x,
-            Left(_) => fail!(reason.to_owned())
+            Left(_) => fail2!("{}", reason.to_owned())
         }
     }
 

src/libstd/fmt/parse.rs

@@ -234,7 +234,7 @@ impl<'self> Parser<'self> {
             Some((_, c @ '#')) | Some((_, c @ '{')) |
             Some((_, c @ '\\')) | Some((_, c @ '}')) => { c }
             Some((_, c)) => {
-                self.err(fmt!("invalid escape character `%c`", c));
+                self.err(format!("invalid escape character `{}`", c));
                 c
             }
             None => {
@@ -378,7 +378,7 @@ impl<'self> Parser<'self> {
                 return None;
             }
             method => {
-                self.err(fmt!("unknown method: `%s`", method));
+                self.err(format!("unknown method: `{}`", method));
                 return None;
             }
         }
@@ -448,8 +448,8 @@ impl<'self> Parser<'self> {
                     Some((_, 'f')) => {
                         let word = self.word();
                         if word != "offset" {
-                            self.err(fmt!("expected `offset`, found `%s`",
-                                          word));
+                            self.err(format!("expected `offset`, found `{}`",
+                                             word));
                         } else {
                             if !self.consume(':') {
                                 self.err(~"`offset` must be followed by `:`");
@@ -490,7 +490,8 @@ impl<'self> Parser<'self> {
                     "few"   => Left(Few),
                     "many"  => Left(Many),
                     word    => {
-                        self.err(fmt!("unexpected plural selector `%s`", word));
+                        self.err(format!("unexpected plural selector `{}`",
+                                         word));
                         if word == "" {
                             break
                         } else {

src/libstd/hash.rs

@@ -493,18 +493,18 @@ mod tests {
         }
 
         while t < 64 {
-            debug!("siphash test %?", t);
+            debug2!("siphash test {}", t);
             let vec = u8to64_le!(vecs[t], 0);
             let out = Bytes(buf.as_slice()).hash_keyed(k0, k1);
-            debug!("got %?, expected %?", out, vec);
+            debug2!("got {:?}, expected {:?}", out, vec);
             assert_eq!(vec, out);
 
             stream_full.reset();
             stream_full.input(buf);
             let f = stream_full.result_str();
             let i = stream_inc.result_str();
             let v = to_hex_str(&vecs[t]);
-            debug!("%d: (%s) => inc=%s full=%s", t, v, i, f);
+            debug2!("{}: ({}) => inc={} full={}", t, v, i, f);
 
             assert!(f == i && f == v);
 

src/libstd/hashmap.rs

@@ -179,7 +179,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
     fn value_for_bucket<'a>(&'a self, idx: uint) -> &'a V {
         match self.buckets[idx] {
             Some(ref bkt) => &bkt.value,
-            None => fail!("HashMap::find: internal logic error"),
+            None => fail2!("HashMap::find: internal logic error"),
         }
     }
 
@@ -196,7 +196,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
     /// True if there was no previous entry with that key
     fn insert_internal(&mut self, hash: uint, k: K, v: V) -> Option<V> {
         match self.bucket_for_key_with_hash(hash, &k) {
-            TableFull => { fail!("Internal logic error"); }
+            TableFull => { fail2!("Internal logic error"); }
             FoundHole(idx) => {
                 self.buckets[idx] = Some(Bucket{hash: hash, key: k,
                                                 value: v});
@@ -205,7 +205,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
             }
             FoundEntry(idx) => {
                 match self.buckets[idx] {
-                    None => { fail!("insert_internal: Internal logic error") }
+                    None => { fail2!("insert_internal: Internal logic error") }
                     Some(ref mut b) => {
                         b.hash = hash;
                         b.key = k;
@@ -374,7 +374,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
 
         let hash = k.hash_keyed(self.k0, self.k1) as uint;
         let idx = match self.bucket_for_key_with_hash(hash, &k) {
-            TableFull => fail!("Internal logic error"),
+            TableFull => fail2!("Internal logic error"),
             FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx }
             FoundHole(idx) => {
                 let v = not_found(&k, a);
@@ -413,7 +413,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     pub fn get<'a>(&'a self, k: &K) -> &'a V {
         match self.find(k) {
             Some(v) => v,
-            None => fail!("No entry found for key: %?", k),
+            None => fail2!("No entry found for key: {:?}", k),
         }
     }
 
@@ -422,7 +422,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     pub fn get_mut<'a>(&'a mut self, k: &K) -> &'a mut V {
         match self.find_mut(k) {
             Some(v) => v,
-            None => fail!("No entry found for key: %?", k),
+            None => fail2!("No entry found for key: {:?}", k),
         }
     }
 
@@ -826,7 +826,7 @@ mod test_map {
         assert!(m.insert(5, 14));
         let new = 100;
         match m.find_mut(&5) {
-            None => fail!(), Some(x) => *x = new
+            None => fail2!(), Some(x) => *x = new
         }
         assert_eq!(m.find(&5), Some(&new));
     }
@@ -943,7 +943,7 @@ mod test_map {
         assert!(m.find(&1).is_none());
         m.insert(1, 2);
         match m.find(&1) {
-            None => fail!(),
+            None => fail2!(),
             Some(v) => assert!(*v == 2)
         }
     }