Reduce reliance on to_str_radix

brendanzab · brendanzab · commit 6943acd1a50b · 2014-02-22T03:56:16.000+11:00
This is in preparation to remove the implementations of ToStrRadix in integers, and to remove the associated logic from `std::num::strconv`.

The parts that still need to be liberated are:

- `std::fmt::Formatter::runplural`
- `num::{bigint, complex, rational}`
diff --git a/src/doc/complement-cheatsheet.md b/src/doc/complement-cheatsheet.md
@@ -22,13 +22,14 @@ let y: int = x.unwrap();
 
 **Int to string, in non-base-10**
 
-Use [`ToStrRadix`](http://static.rust-lang.org/doc/master/std/num/trait.ToStrRadix.html).
+Use the `format!` syntax extension.
 
 ~~~
-use std::num::ToStrRadix;
-
 let x: int = 42;
-let y: ~str = x.to_str_radix(16);
+let y: ~str = format!("{:t}", x);   // binary
+let y: ~str = format!("{:o}", x);   // octal
+let y: ~str = format!("{:x}", x);   // lowercase hexadecimal
+let y: ~str = format!("{:X}", x);   // uppercase hexidecimal
 ~~~
 
 **String to int, in non-base-10**
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -2024,7 +2024,7 @@ impl ops::Sub<TypeContents,TypeContents> for TypeContents {
 
 impl ToStr for TypeContents {
     fn to_str(&self) -> ~str {
-        format!("TypeContents({})", self.bits.to_str_radix(2))
+        format!("TypeContents({:t})", self.bits)
     }
 }
 
diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs
@@ -70,8 +70,7 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         match *self {
           Redirect(ref vid) => format!("Redirect({})", vid.to_str()),
-          Root(ref pt, rk) => format!("Root({}, {})", pt.inf_str(cx),
-                               rk.to_str_radix(10u))
+          Root(ref pt, rk) => format!("Root({}, {})", pt.inf_str(cx), rk)
         }
     }
 }
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
@@ -29,7 +29,6 @@
 use container::Container;
 use io::{Writer, IoResult};
 use iter::Iterator;
-use num::ToStrRadix;
 use option::{Some, None};
 use result::Ok;
 use str::OwnedStr;
@@ -281,7 +280,7 @@ impl Streaming for SipState {
         let r = self.result_bytes();
         let mut s = ~"";
         for b in r.iter() {
-            s.push_str((*b as uint).to_str_radix(16u));
+            s.push_str(format!("{:x}", *b));
         }
         s
     }
@@ -391,7 +390,7 @@ mod tests {
         fn to_hex_str(r: &[u8, ..8]) -> ~str {
             let mut s = ~"";
             for b in r.iter() {
-                s.push_str((*b as uint).to_str_radix(16u));
+                s.push_str(format!("{:x}", *b));
             }
             s
         }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
@@ -857,12 +857,12 @@ pub trait Writer {
 
     /// Write the result of passing n through `int::to_str_bytes`.
     fn write_int(&mut self, n: int) -> IoResult<()> {
-        int::to_str_bytes(n, 10u, |bytes| self.write(bytes))
+        write!(self, "{:d}", n)
     }
 
     /// Write the result of passing n through `uint::to_str_bytes`.
     fn write_uint(&mut self, n: uint) -> IoResult<()> {
-        uint::to_str_bytes(n, 10u, |bytes| self.write(bytes))
+        write!(self, "{:u}", n)
     }
 
     /// Write a little-endian uint (number of bytes depends on system).
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
@@ -401,7 +401,7 @@ impl ToStr for $T {
     /// Convert to a string in base 10.
     #[inline]
     fn to_str(&self) -> ~str {
-        self.to_str_radix(10)
+        format!("{:d}", *self)
     }
 }
 
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
@@ -245,7 +245,7 @@ impl ToStr for $T {
     /// Convert to a string in base 10.
     #[inline]
     fn to_str(&self) -> ~str {
-        self.to_str_radix(10u)
+        format!("{:u}", *self)
     }
 }
 
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
@@ -60,19 +60,13 @@ impl Repr for bool {
 
 impl Repr for int {
     fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> {
-        ::int::to_str_bytes(*self, 10u, |bits| {
-            writer.write(bits)
-        })
+        write!(writer, "{}", *self)
     }
 }
 
 macro_rules! int_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty {
     fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> {
-        ::$ty::to_str_bytes(*self, 10u, |bits| {
-            writer.write(bits).and_then(|()| {
-                writer.write(bytes!($suffix))
-            })
-        })
+        write!(writer, "{}{}", *self, $suffix)
     }
 }))
 
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -2267,29 +2267,14 @@ pub fn print_literal(s: &mut State, lit: &ast::Lit) -> io::IoResult<()> {
           word(&mut s.s, res)
       }
       ast::LitInt(i, t) => {
-        if i < 0_i64 {
-            word(&mut s.s,
-                 ~"-" + (-i as u64).to_str_radix(10u)
-                 + ast_util::int_ty_to_str(t))
-        } else {
-            word(&mut s.s,
-                 (i as u64).to_str_radix(10u)
-                 + ast_util::int_ty_to_str(t))
-        }
+        word(&mut s.s, format!("{}{}", i, ast_util::int_ty_to_str(t)))
       }
       ast::LitUint(u, t) => {
-        word(&mut s.s,
-             u.to_str_radix(10u)
-             + ast_util::uint_ty_to_str(t))
+        word(&mut s.s, format!("{}{}", u, ast_util::uint_ty_to_str(t)))
       }
       ast::LitIntUnsuffixed(i) => {
-        if i < 0_i64 {
-            word(&mut s.s, ~"-" + (-i as u64).to_str_radix(10u))
-        } else {
-            word(&mut s.s, (i as u64).to_str_radix(10u))
-        }
+        word(&mut s.s, format!("{}", i))
       }
-
       ast::LitFloat(ref f, t) => {
         word(&mut s.s, f.get() + ast_util::float_ty_to_str(t))
       }
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
@@ -12,7 +12,6 @@
 
 use std::{char, vec};
 use std::mem::replace;
-use std::num::strconv::{SignNone,SignNeg,SignAll,int_to_str_bytes_common};
 
 #[deriving(Eq)]
 enum States {
@@ -480,68 +479,49 @@ impl FormatOp {
 fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
     let mut s = match val {
         Number(d) => {
+            let mut s = match (op, flags.sign) {
+                (FormatDigit, true)  => format!("{:+d}", d).into_bytes(),
+                (FormatDigit, false) => format!("{:d}", d).into_bytes(),
+                (FormatOctal, _)     => format!("{:o}", d).into_bytes(),
+                (FormatHex, _)       => format!("{:x}", d).into_bytes(),
+                (FormatHEX, _)       => format!("{:X}", d).into_bytes(),
+                (FormatString, _)    => return Err(~"non-number on stack with %s"),
+            };
+            if flags.precision > s.len() {
+                let mut s_ = vec::with_capacity(flags.precision);
+                let n = flags.precision - s.len();
+                s_.grow(n, &('0' as u8));
+                s_.push_all_move(s);
+                s = s_;
+            }
+            assert!(!s.is_empty(), "string conversion produced empty result");
             match op {
-                FormatString => {
-                    return Err(~"non-number on stack with %s")
+                FormatDigit => {
+                    if flags.space && !(s[0] == '-' as u8 || s[0] == '+' as u8) {
+                        s.unshift(' ' as u8);
+                    }
                 }
-                _ => {
-                    let radix = match op {
-                        FormatDigit => 10,
-                        FormatOctal => 8,
-                        FormatHex|FormatHEX => 16,
-                        FormatString => unreachable!()
-                    };
-                    let mut s = ~[];
-                    match op {
-                        FormatDigit => {
-                            let sign = if flags.sign { SignAll } else { SignNeg };
-                            int_to_str_bytes_common(d, radix, sign, |c| {
-                                s.push(c);
-                            })
-                        }
-                        _ => {
-                            int_to_str_bytes_common(d as uint, radix, SignNone, |c| {
-                                s.push(c);
-                            })
-                        }
-                    };
-                    if flags.precision > s.len() {
-                        let mut s_ = vec::with_capacity(flags.precision);
-                        let n = flags.precision - s.len();
-                        s_.grow(n, &('0' as u8));
-                        s_.push_all_move(s);
-                        s = s_;
+                FormatOctal => {
+                    if flags.alternate && s[0] != '0' as u8 {
+                        s.unshift('0' as u8);
                     }
-                    assert!(!s.is_empty(), "string conversion produced empty result");
-                    match op {
-                        FormatDigit => {
-                            if flags.space && !(s[0] == '-' as u8 || s[0] == '+' as u8) {
-                                s.unshift(' ' as u8);
-                            }
-                        }
-                        FormatOctal => {
-                            if flags.alternate && s[0] != '0' as u8 {
-                                s.unshift('0' as u8);
-                            }
-                        }
-                        FormatHex => {
-                            if flags.alternate {
-                                let s_ = replace(&mut s, ~['0' as u8, 'x' as u8]);
-                                s.push_all_move(s_);
-                            }
-                        }
-                        FormatHEX => {
-                            s = s.into_ascii().to_upper().into_bytes();
-                            if flags.alternate {
-                                let s_ = replace(&mut s, ~['0' as u8, 'X' as u8]);
-                                s.push_all_move(s_);
-                            }
-                        }
-                        FormatString => unreachable!()
+                }
+                FormatHex => {
+                    if flags.alternate {
+                        let s_ = replace(&mut s, ~['0' as u8, 'x' as u8]);
+                        s.push_all_move(s_);
+                    }
+                }
+                FormatHEX => {
+                    s = s.into_ascii().to_upper().into_bytes();
+                    if flags.alternate {
+                        let s_ = replace(&mut s, ~['0' as u8, 'X' as u8]);
+                        s.push_all_move(s_);
                     }
-                    s
                 }
+                FormatString => unreachable!()
             }
+            s
         }
         String(s) => {
             match op {

Original file line number	Diff line number	Diff line change
`@@ -2024,7 +2024,7 @@ impl ops::Sub<TypeContents,TypeContents> for TypeContents {`
`2024`	`2024`
`2025`	`2025`	`impl ToStr for TypeContents {`
`2026`	`2026`	`fn to_str(&self) -> ~str {`
`2027`		`- format!("TypeContents({})", self.bits.to_str_radix(2))`
	`2027`	`+ format!("TypeContents({:t})", self.bits)`
`2028`	`2028`	`}`
`2029`	`2029`	`}`
`2030`	`2030`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,7 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {`
`70`	`70`	`fn inf_str(&self, cx: &InferCtxt) -> ~str {`
`71`	`71`	`match *self {`
`72`	`72`	`Redirect(ref vid) => format!("Redirect({})", vid.to_str()),`
`73`		`- Root(ref pt, rk) => format!("Root({}, {})", pt.inf_str(cx),`
`74`		`- rk.to_str_radix(10u))`
	`73`	`+ Root(ref pt, rk) => format!("Root({}, {})", pt.inf_str(cx), rk)`
`75`	`74`	`}`
`76`	`75`	`}`
`77`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,6 @@`
`29`	`29`	`use container::Container;`
`30`	`30`	`use io::{Writer, IoResult};`
`31`	`31`	`use iter::Iterator;`
`32`		`-use num::ToStrRadix;`
`33`	`32`	`use option::{Some, None};`
`34`	`33`	`use result::Ok;`
`35`	`34`	`use str::OwnedStr;`
`@@ -281,7 +280,7 @@ impl Streaming for SipState {`
`281`	`280`	`let r = self.result_bytes();`
`282`	`281`	`let mut s = ~"";`
`283`	`282`	`for b in r.iter() {`
`284`		`- s.push_str((*b as uint).to_str_radix(16u));`
	`283`	`+ s.push_str(format!("{:x}", *b));`
`285`	`284`	`}`
`286`	`285`	`s`
`287`	`286`	`}`
`@@ -391,7 +390,7 @@ mod tests {`
`391`	`390`	`fn to_hex_str(r: &[u8, ..8]) -> ~str {`
`392`	`391`	`let mut s = ~"";`
`393`	`392`	`for b in r.iter() {`
`394`		`- s.push_str((*b as uint).to_str_radix(16u));`
	`393`	`+ s.push_str(format!("{:x}", *b));`
`395`	`394`	`}`
`396`	`395`	`s`
`397`	`396`	`}`
Original file line number	Diff line number	Diff line change
`@@ -857,12 +857,12 @@ pub trait Writer {`
`857`	`857`
`858`	`858`	/// Write the result of passing n through `int::to_str_bytes`.
`859`	`859`	`fn write_int(&mut self, n: int) -> IoResult<()> {`
`860`		`- int::to_str_bytes(n, 10u, \|bytes\| self.write(bytes))`
	`860`	`+ write!(self, "{:d}", n)`
`861`	`861`	`}`
`862`	`862`
`863`	`863`	/// Write the result of passing n through `uint::to_str_bytes`.
`864`	`864`	`fn write_uint(&mut self, n: uint) -> IoResult<()> {`
`865`		`- uint::to_str_bytes(n, 10u, \|bytes\| self.write(bytes))`
	`865`	`+ write!(self, "{:u}", n)`
`866`	`866`	`}`
`867`	`867`
`868`	`868`	`/// Write a little-endian uint (number of bytes depends on system).`
Original file line number	Diff line number	Diff line change
`@@ -401,7 +401,7 @@ impl ToStr for $T {`
`401`	`401`	`/// Convert to a string in base 10.`
`402`	`402`	`#[inline]`
`403`	`403`	`fn to_str(&self) -> ~str {`
`404`		`- self.to_str_radix(10)`
	`404`	`+ format!("{:d}", *self)`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`
Original file line number	Diff line number	Diff line change
`@@ -245,7 +245,7 @@ impl ToStr for $T {`
`245`	`245`	`/// Convert to a string in base 10.`
`246`	`246`	`#[inline]`
`247`	`247`	`fn to_str(&self) -> ~str {`
`248`		`- self.to_str_radix(10u)`
	`248`	`+ format!("{:u}", *self)`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
Original file line number	Diff line number	Diff line change
`@@ -60,19 +60,13 @@ impl Repr for bool {`
`60`	`60`
`61`	`61`	`impl Repr for int {`
`62`	`62`	`fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> {`
`63`		`- ::int::to_str_bytes(*self, 10u, \|bits\| {`
`64`		`- writer.write(bits)`
`65`		`- })`
	`63`	`+ write!(writer, "{}", *self)`
`66`	`64`	`}`
`67`	`65`	`}`
`68`	`66`
`69`	`67`	`macro_rules! int_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty {`
`70`	`68`	`fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> {`
`71`		`- ::$ty::to_str_bytes(*self, 10u, \|bits\| {`
`72`		`- writer.write(bits).and_then(\|()\| {`
`73`		`- writer.write(bytes!($suffix))`
`74`		`- })`
`75`		`- })`
	`69`	`+ write!(writer, "{}{}", *self, $suffix)`
`76`	`70`	`}`
`77`	`71`	`}))`
`78`	`72`