Updates with core::fmt changes

1. Wherever the `buf` field of a `Formatter` was used, the `Formatter` is used instead. 2. The usage of `write_fmt` is minimized as much as possible, the `write!` macro is preferred wherever possible. 3. Usage of `fmt::write` is minimized, favoring the `write!` macro instead.
rust-lang · May 10, 2014 · 1de4b65d2a88e88201026485f9622916c5717555 · 1de4b65
1 parent 8767093
commit 1de4b65d2a88e88201026485f9622916c5717555
diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs
@@ -425,8 +425,8 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Leaf<K, V> {
    ///Returns a string representation of a Leaf.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        for (i, s) in self.elts.iter().enumerate() {
-  
-            if i != 0 { try!(write!(f.buf, " // ")) }
-  
-            try!(write!(f.buf, "{}", *s))
+  
+            if i != 0 { try!(write!(f, " // ")) }
+  
+            try!(write!(f, "{}", *s))
        }
        Ok(())
    }
@@ -654,10 +654,10 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Branch<K, V> {
    ///Returns a string representation of a Branch.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        for (i, s) in self.elts.iter().enumerate() {
-  
-            if i != 0 { try!(write!(f.buf, " // ")) }
-  
-            try!(write!(f.buf, "{}", *s))
+  
+            if i != 0 { try!(write!(f, " // ")) }
+  
+            try!(write!(f, "{}", *s))
        }
-  
-        write!(f.buf, " // rightmost child: ({}) ", *self.rightmost_child)
+  
+        write!(f, " // rightmost child: ({}) ", *self.rightmost_child)
    }
 }
@@ -715,7 +715,7 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for LeafElt<K, V> {
 impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for LeafElt<K, V> {
    ///Returns a string representation of a LeafElt.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "Key: {}, value: {};", self.key, self.value)
+  
+        write!(f, "Key: {}, value: {};", self.key, self.value)
    }
 }
@@ -765,7 +765,7 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for BranchElt<K, V> {
    /// Returns string containing key, value, and child (which should recur to a
    /// leaf) Consider changing in future to be more readable.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "Key: {}, value: {}, (child: {})",
+  
+        write!(f, "Key: {}, value: {}, (child: {})",
               self.key, self.value, *self.left)
    }
 }

diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs
@@ -1418,14 +1418,14 @@ impl<K: TotalEq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {
 impl<K: TotalEq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        try!(write!(f.buf, r"\{"));
+  
+        try!(write!(f, r"\{"));
        for (i, (k, v)) in self.iter().enumerate() {
-  
-            if i != 0 { try!(write!(f.buf, ", ")); }
-  
-            try!(write!(f.buf, "{}: {}", *k, *v));
+  
+            if i != 0 { try!(write!(f, ", ")); }
+  
+            try!(write!(f, "{}: {}", *k, *v));
        }
-  
-        write!(f.buf, r"\}")
+  
+        write!(f, r"\}")
    }
 }
@@ -1605,14 +1605,14 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
 impl<T: TotalEq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        try!(write!(f.buf, r"\{"));
+  
+        try!(write!(f, r"\{"));
        for (i, x) in self.iter().enumerate() {
-  
-            if i != 0 { try!(write!(f.buf, ", ")); }
-  
-            try!(write!(f.buf, "{}", *x));
+  
+            if i != 0 { try!(write!(f, ", ")); }
+  
+            try!(write!(f, "{}", *x));
        }
-  
-        write!(f.buf, r"\}")
+  
+        write!(f, r"\}")
    }
 }

diff --git a/src/libcollections/lru_cache.rs b/src/libcollections/lru_cache.rs
@@ -205,20 +205,20 @@ impl<A: fmt::Show + Hash + TotalEq, B: fmt::Show> fmt::Show for LruCache<A, B> {
    /// Return a string that lists the key-value pairs from most-recently
    /// used to least-recently used.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        try!(write!(f.buf, r"\{"));
+  
+        try!(write!(f, r"\{"));
        let mut cur = self.head;
        for i in range(0, self.len()) {
-  
-            if i > 0 { try!(write!(f.buf, ", ")) }
+  
+            if i > 0 { try!(write!(f, ", ")) }
            unsafe {
                cur = (*cur).next;
-  
-                try!(write!(f.buf, "{}", (*cur).key));
+  
+                try!(write!(f, "{}", (*cur).key));
            }
-  
-            try!(write!(f.buf, ": "));
+  
+            try!(write!(f, ": "));
            unsafe {
-  
-                try!(write!(f.buf, "{}", (*cur).value));
+  
+                try!(write!(f, "{}", (*cur).value));
            }
        }
-  
-        write!(f.buf, r"\}")
+  
+        write!(f, r"\}")
    }
 }

diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
@@ -35,7 +35,7 @@ pub use iter::{FromIterator, Extendable};
 pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};
-  
-pub use num::{Signed, Unsigned};
+  
+pub use num::{Signed, Unsigned, Float};
 pub use num::{Primitive, Int, ToPrimitive, FromPrimitive};
 pub use ptr::RawPtr;
 pub use str::{Str, StrSlice};

diff --git a/src/libgreen/macros.rs b/src/libgreen/macros.rs
@@ -51,11 +51,9 @@ macro_rules! rtabort (
 )
 pub fn dumb_println(args: &fmt::Arguments) {
-  
-    use std::io;
    use std::rt;
-  
-
    let mut w = rt::Stderr;
-  
-    let _ = fmt::writeln(&mut w as &mut io::Writer, args);
+  
+    let _ = writeln!(&mut w, "{}", args);
 }
 pub fn abort(msg: &str) -> ! {

diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
@@ -188,7 +188,7 @@ impl fmt::Show for LogLevel {
 impl fmt::Signed for LogLevel {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let LogLevel(level) = *self;
-  
-        write!(fmt.buf, "{}", level)
+  
+        write!(fmt, "{}", level)
    }
 }

diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
@@ -120,7 +120,7 @@ impl Default for BigUint {
 impl fmt::Show for BigUint {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "{}", self.to_str_radix(10))
+  
+        write!(f, "{}", self.to_str_radix(10))
    }
 }
@@ -843,7 +843,7 @@ impl Default for BigInt {
 impl fmt::Show for BigInt {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "{}", self.to_str_radix(10))
+  
+        write!(f, "{}", self.to_str_radix(10))
    }
 }

diff --git a/src/libnum/complex.rs b/src/libnum/complex.rs
@@ -171,9 +171,9 @@ impl<T: Clone + Num> One for Complex<T> {
 impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.im < Zero::zero() {
-  
-            write!(f.buf, "{}-{}i", self.re, -self.im)
+  
+            write!(f, "{}-{}i", self.re, -self.im)
        } else {
-  
-            write!(f.buf, "{}+{}i", self.re, self.im)
+  
+            write!(f, "{}+{}i", self.re, self.im)
        }
    }
 }

diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs
@@ -276,7 +276,7 @@ impl<T: Clone + Integer + Ord>
 impl<T: fmt::Show> fmt::Show for Ratio<T> {
    /// Renders as `numer/denom`.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "{}/{}", self.numer, self.denom)
+  
+        write!(f, "{}/{}", self.numer, self.denom)
    }
 }
 impl<T: ToStrRadix> ToStrRadix for Ratio<T> {

diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
@@ -37,7 +37,7 @@ pub struct Error {
 impl fmt::Show for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "Regex syntax error near position {}: {}",
+  
+        write!(f, "Regex syntax error near position {}: {}",
               self.pos, self.msg)
    }
 }

diff --git a/src/libregex/re.rs b/src/libregex/re.rs
@@ -117,7 +117,7 @@ pub struct Regex {
 impl fmt::Show for Regex {
    /// Shows the original regular expression.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "{}", self.original)
+  
+        write!(f, "{}", self.original)
    }
 }

diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
@@ -15,9 +15,7 @@
 use std::cell::RefCell;
 use collections::HashMap;
-  
-use std::io;
 use std::io::MemWriter;
-  
-use std::fmt;
 use middle::ty::param_ty;
 use middle::ty;
@@ -28,9 +26,7 @@ use syntax::ast::*;
 use syntax::diagnostic::SpanHandler;
 use syntax::parse::token;
-  
-macro_rules! mywrite( ($wr:expr, $($arg:tt)*) => (
-  
-    format_args!(|a| { mywrite($wr, a) }, $($arg)*)
-  
-) )
+  
+macro_rules! mywrite( ($($arg:tt)*) => ({ write!($($arg)*); }) )
 pub struct ctxt<'a> {
    pub diag: &'a SpanHandler,
@@ -52,10 +48,6 @@ pub struct ty_abbrev {
 pub type abbrev_map = RefCell<HashMap<ty::t, ty_abbrev>>;
-  
-fn mywrite(w: &mut MemWriter, fmt: &fmt::Arguments) {
-  
-    fmt::write(&mut *w as &mut io::Writer, fmt);
-  
-}
-  
-
 pub fn enc_ty(w: &mut MemWriter, cx: &ctxt, t: ty::t) {
    match cx.abbrevs.borrow_mut().find(&t) {
        Some(a) => { w.write(a.s.as_bytes()); return; }

diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -183,13 +183,13 @@ pub fn check_crate(tcx: &ty::ctxt,
 impl fmt::Show for LiveNode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "ln({})", self.get())
+  
+        write!(f, "ln({})", self.get())
    }
 }
 impl fmt::Show for Variable {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "v({})", self.get())
+  
+        write!(f, "v({})", self.get())
    }
 }

diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -388,7 +388,7 @@ pub struct t { inner: *t_opaque }
 impl fmt::Show for t {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        f.buf.write_str("*t_opaque")
+  
+        "*t_opaque".fmt(f)
    }
 }
@@ -912,7 +912,7 @@ impl Vid for TyVid {
 impl fmt::Show for TyVid {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
-  
-        write!(f.buf, "<generic \\#{}>", self.to_uint())
+  
+        write!(f, "<generic \\#{}>", self.to_uint())
    }
 }
@@ -922,7 +922,7 @@ impl Vid for IntVid {
 impl fmt::Show for IntVid {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "<generic integer \\#{}>", self.to_uint())
+  
+        write!(f, "<generic integer \\#{}>", self.to_uint())
    }
 }
@@ -932,7 +932,7 @@ impl Vid for FloatVid {
 impl fmt::Show for FloatVid {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "<generic float \\#{}>", self.to_uint())
+  
+        write!(f, "<generic float \\#{}>", self.to_uint())
    }
 }
@@ -949,7 +949,7 @@ impl fmt::Show for RegionVid {
 impl fmt::Show for FnSig {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // grr, without tcx not much we can do.
-  
-        write!(f.buf, "(...)")
+  
+        write!(f, "(...)")
    }
 }
@@ -1987,7 +1987,7 @@ impl ops::Sub<TypeContents,TypeContents> for TypeContents {
 impl fmt::Show for TypeContents {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-  
-        write!(f.buf, "TypeContents({:t})", self.bits)
+  
+        write!(f, "TypeContents({:t})", self.bits)
    }
 }

diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs
@@ -240,9 +240,9 @@ enum VarianceTerm<'a> {
 impl<'a> fmt::Show for VarianceTerm<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
-  
-            ConstantTerm(c1) => write!(f.buf, "{}", c1),
-  
-            TransformTerm(v1, v2) => write!(f.buf, "({} \u00D7 {})", v1, v2),
-  
-            InferredTerm(id) => write!(f.buf, "[{}]", { let InferredIndex(i) = id; i })
+  
+            ConstantTerm(c1) => write!(f, "{}", c1),
+  
+            TransformTerm(v1, v2) => write!(f, "({} \u00D7 {})", v1, v2),
+  
+            InferredTerm(id) => write!(f, "[{}]", { let InferredIndex(i) = id; i })
        }
    }
 }

diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs
@@ -29,7 +29,7 @@ impl<'a> fmt::Show for Escape<'a> {
        for (i, ch) in s.bytes().enumerate() {
            match ch as char {
                '<' | '>' | '&' | '\'' | '"' => {
-  
-                    try!(fmt.buf.write(pile_o_bits.slice(last, i).as_bytes()));
+  
+                    try!(fmt.write(pile_o_bits.slice(last, i).as_bytes()));
                    let s = match ch as char {
                        '>' => "&gt;",
                        '<' => "&lt;",
@@ -38,15 +38,15 @@ impl<'a> fmt::Show for Escape<'a> {
                        '"' => "&quot;",
                        _ => unreachable!()
                    };
-  
-                    try!(fmt.buf.write(s.as_bytes()));
+  
+                    try!(fmt.write(s.as_bytes()));
                    last = i + 1;
                }
                _ => {}
            }
        }
        if last < s.len() {
-  
-            try!(fmt.buf.write(pile_o_bits.slice_from(last).as_bytes()));
+  
+            try!(fmt.write(pile_o_bits.slice_from(last).as_bytes()));
        }
        Ok(())
    }