rm obsolete integer to_str{,_radix} free functions

doc/rust.md

@@ -2864,17 +2864,16 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of `
 An example of an object type:
 
 ~~~~~~~~
-# use std::int;
 trait Printable {
-  fn to_str(&self) -> ~str;
+  fn to_string(&self) -> ~str;
 }
 
 impl Printable for int {
-  fn to_str(&self) -> ~str { int::to_str(*self) }
+  fn to_string(&self) -> ~str { self.to_str() }
 }
 
 fn print(a: @Printable) {
-   println(a.to_str());
+   println(a.to_string());
 }
 
 fn main() {

doc/tutorial.md

@@ -555,12 +555,11 @@ while cake_amount > 0 {
 `loop` denotes an infinite loop, and is the preferred way of writing `while true`:
 
 ~~~~
-use std::int;
+let mut x = 5u;
-let mut x = 5;
 loop {
     x += x - 3;
     if x % 5 == 0 { break; }
-    println(int::to_str(x));
+    println(x.to_str());
 }
 ~~~~
 

src/libextra/crypto/digest.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::uint;
 use std::vec;
 
 
@@ -71,7 +70,7 @@ pub trait Digest {
 fn to_hex(rr: &[u8]) -> ~str {
     let mut s = ~"";
     for b in rr.iter() {
-        let hex = uint::to_str_radix(*b as uint, 16u);
+        let hex = (*b as uint).to_str_radix(16u);
         if hex.len() == 1 {
             s.push_char('0');
         }

src/libextra/md4.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-use std::uint;
 use std::vec;
 
 struct Quad {
@@ -121,7 +120,7 @@ pub fn md4_str(msg: &[u8]) -> ~str {
             if byte <= 16u8 {
                 result.push_char('0')
             }
-            result.push_str(uint::to_str_radix(byte as uint, 16u));
+            result.push_str((byte as uint).to_str_radix(16u));
             i += 1u32;
         }
     }

src/libextra/num/bigint.rs

@@ -525,7 +525,7 @@ impl ToStrRadix for BigUint {
             if v.is_empty() { return ~"0" }
             let mut s = str::with_capacity(v.len() * l);
             for n in v.rev_iter() {
-                let ss = uint::to_str_radix(*n as uint, radix);
+                let ss = (*n as uint).to_str_radix(radix);
                 s.push_str("0".repeat(l - ss.len()));
                 s.push_str(ss);
             }

src/libextra/time.rs

@@ -10,8 +10,6 @@
 
 #[allow(missing_doc)];
 
-
-use std::int;
 use std::io;
 use std::num;
 use std::str;
@@ -824,7 +822,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
           //'U' {}
           'u' => {
             let i = tm.tm_wday as int;
-            int::to_str(if i == 0 { 7 } else { i })
+            (if i == 0 { 7 } else { i }).to_str()
           }
           //'V' {}
           'v' => {
@@ -834,10 +832,10 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
                 parse_type('Y', tm))
           }
           //'W' {}
-          'w' => int::to_str(tm.tm_wday as int),
+          'w' => (tm.tm_wday as int).to_str(),
           //'X' {}
           //'x' {}
-          'Y' => int::to_str(tm.tm_year as int + 1900),
+          'Y' => (tm.tm_year as int + 1900).to_str(),
           'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
           'Z' => tm.tm_zone.clone(),
           'z' => {

src/librustc/driver/driver.rs

@@ -26,7 +26,6 @@ use util::common::time;
 use util::ppaux;
 
 use std::hashmap::{HashMap,HashSet};
-use std::int;
 use std::io;
 use std::os;
 use std::vec;
@@ -454,21 +453,21 @@ pub fn pretty_print_input(sess: Session, cfg: ast::CrateConfig, input: &input,
         match node {
           pprust::node_item(s, item) => {
             pp::space(s.s);
-            pprust::synth_comment(s, int::to_str(item.id));
+            pprust::synth_comment(s, item.id.to_str());
           }
           pprust::node_block(s, ref blk) => {
             pp::space(s.s);
             pprust::synth_comment(
-                s, ~"block " + int::to_str(blk.id));
+                s, ~"block " + blk.id.to_str());
           }
           pprust::node_expr(s, expr) => {
             pp::space(s.s);
-            pprust::synth_comment(s, int::to_str(expr.id));
+            pprust::synth_comment(s, expr.id.to_str());
             pprust::pclose(s);
           }
           pprust::node_pat(s, pat) => {
             pp::space(s.s);
-            pprust::synth_comment(s, ~"pat " + int::to_str(pat.id));
+            pprust::synth_comment(s, ~"pat " + pat.id.to_str());
           }
         }
     }

src/librustc/metadata/encoder.rs

@@ -25,7 +25,6 @@ use std::hash::HashUtil;
 use std::hashmap::{HashMap, HashSet};
 use std::io;
 use std::str;
-use std::uint;
 use std::vec;
 use extra::flate;
 use extra::serialize::Encodable;
@@ -303,7 +302,7 @@ fn encode_disr_val(_: &EncodeContext,
                    ebml_w: &mut writer::Encoder,
                    disr_val: uint) {
     ebml_w.start_tag(tag_disr_val);
-    let s = uint::to_str(disr_val);
+    let s = disr_val.to_str();
     ebml_w.writer.write(s.as_bytes());
     ebml_w.end_tag();
 }

src/librustc/metadata/tyencode.rs

@@ -17,7 +17,6 @@ use middle::ty;
 use std::hashmap::HashMap;
 use std::io::WriterUtil;
 use std::io;
-use std::uint;
 use syntax::abi::AbiSet;
 use syntax::ast;
 use syntax::ast::*;
@@ -324,7 +323,7 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, st: &ty::sty) {
         w.write_char('p');
         w.write_str((cx.ds)(did));
         w.write_char('|');
-        w.write_str(uint::to_str(id));
+        w.write_str(id.to_str());
       }
       ty::ty_self(did) => {
         w.write_char('s');

src/librustc/middle/trans/base.rs

@@ -71,7 +71,6 @@ use std::hash;
 use std::hashmap::HashMap;
 use std::io;
 use std::libc::c_uint;
-use std::uint;
 use std::vec;
 use std::local_data;
 use extra::time;
@@ -719,7 +718,7 @@ pub fn iter_structural_ty(cx: @mut Block, av: ValueRef, t: ty::t,
                   for variant in (*variants).iter() {
                       let variant_cx =
                           sub_block(cx, ~"enum-iter-variant-" +
-                                    uint::to_str(variant.disr_val));
+                                    variant.disr_val.to_str());
                       let variant_cx =
                           iter_variant(variant_cx, repr, av, *variant,
                                        substs.tps, |x,y,z| f(x,y,z));

src/librustc/middle/ty.rs

@@ -33,7 +33,6 @@ use std::ops;
 use std::ptr::to_unsafe_ptr;
 use std::to_bytes;
 use std::to_str::ToStr;
-use std::u32;
 use std::vec;
 use syntax::ast::*;
 use syntax::ast_util::is_local;
@@ -1944,7 +1943,7 @@ impl ops::Sub<TypeContents,TypeContents> for TypeContents {
 
 impl ToStr for TypeContents {
     fn to_str(&self) -> ~str {
-        fmt!("TypeContents(%s)", u32::to_str_radix(self.bits, 2))
+        fmt!("TypeContents(%s)", self.bits.to_str_radix(2))
     }
 }
 

src/librustc/middle/typeck/infer/to_str.rs

@@ -17,7 +17,6 @@ use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::unify::{Redirect, Root, VarValue};
 use util::ppaux::{mt_to_str, ty_to_str, trait_ref_to_str};
 
-use std::uint;
 use syntax::ast;
 
 pub trait InferStr {
@@ -72,7 +71,7 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
         match *self {
           Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()),
           Root(ref pt, rk) => fmt!("Root(%s, %s)", pt.inf_str(cx),
-                               uint::to_str_radix(rk, 10u))
+                               rk.to_str_radix(10u))
         }
     }
 }

src/libstd/hash.rs

@@ -27,8 +27,8 @@ use option::{Some, None};
 use rt::io::Writer;
 use str::OwnedStr;
 use to_bytes::IterBytes;
-use uint;
 use vec::ImmutableVector;
+use num::ToStrRadix;
 
 // Alias `SipState` to `State`.
 pub use State = hash::SipState;
@@ -386,7 +386,7 @@ impl Streaming for SipState {
         let r = self.result_bytes();
         let mut s = ~"";
         for b in r.iter() {
-            s.push_str(uint::to_str_radix(*b as uint, 16u));
+            s.push_str((*b as uint).to_str_radix(16u));
         }
         s
     }
@@ -407,8 +407,6 @@ mod tests {
     use super::*;
     use prelude::*;
 
-    use uint;
-
     // Hash just the bytes of the slice, without length prefix
     struct Bytes<'self>(&'self [u8]);
     impl<'self> IterBytes for Bytes<'self> {
@@ -496,7 +494,7 @@ mod tests {
         fn to_hex_str(r: &[u8, ..8]) -> ~str {
             let mut s = ~"";
             for b in r.iter() {
-                s.push_str(uint::to_str_radix(*b as uint, 16u));
+                s.push_str((*b as uint).to_str_radix(16u));
             }
             s
         }

src/libstd/num/int_macros.rs

@@ -525,36 +525,26 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: &fn(v: &[u8]) -> U) -> U {
     f(buf.slice(0, cur))
 }
 
+impl ToStr for $T {
     /// Convert to a string in base 10.
     #[inline]
-pub fn to_str(num: $T) -> ~str {
+    fn to_str(&self) -> ~str {
-    to_str_radix(num, 10u)
+        self.to_str_radix(10)
+    }
 }
 
+impl ToStrRadix for $T {
     /// Convert to a string in a given base.
     #[inline]
-pub fn to_str_radix(num: $T, radix: uint) -> ~str {
+    fn to_str_radix(&self, radix: uint) -> ~str {
         let mut buf: ~[u8] = ~[];
-    do strconv::int_to_str_bytes_common(num, radix, strconv::SignNeg) |i| {
+        do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNeg) |i| {
             buf.push(i);
         }
         // We know we generated valid utf-8, so we don't need to go through that
         // check.
         unsafe { str::raw::from_bytes_owned(buf) }
     }
-
-impl ToStr for $T {
-    #[inline]
-    fn to_str(&self) -> ~str {
-        to_str(*self)
-    }
-}
-
-impl ToStrRadix for $T {
-    #[inline]
-    fn to_str_radix(&self, radix: uint) -> ~str {
-        to_str_radix(*self, radix)
-    }
 }
 
 #[cfg(test)]
@@ -813,39 +803,39 @@ mod tests {
 
     #[test]
     fn test_to_str() {
-        assert_eq!(to_str_radix(0 as $T, 10u), ~"0");
+        assert_eq!((0 as $T).to_str_radix(10u), ~"0");
-        assert_eq!(to_str_radix(1 as $T, 10u), ~"1");
+        assert_eq!((1 as $T).to_str_radix(10u), ~"1");
-        assert_eq!(to_str_radix(-1 as $T, 10u), ~"-1");
+        assert_eq!((-1 as $T).to_str_radix(10u), ~"-1");
-        assert_eq!(to_str_radix(127 as $T, 16u), ~"7f");
+        assert_eq!((127 as $T).to_str_radix(16u), ~"7f");
-        assert_eq!(to_str_radix(100 as $T, 10u), ~"100");
+        assert_eq!((100 as $T).to_str_radix(10u), ~"100");
 
     }
 
     #[test]
     fn test_int_to_str_overflow() {
         let mut i8_val: i8 = 127_i8;
-        assert_eq!(i8::to_str(i8_val), ~"127");
+        assert_eq!(i8_val.to_str(), ~"127");
 
         i8_val += 1 as i8;
-        assert_eq!(i8::to_str(i8_val), ~"-128");
+        assert_eq!(i8_val.to_str(), ~"-128");
 
         let mut i16_val: i16 = 32_767_i16;
-        assert_eq!(i16::to_str(i16_val), ~"32767");
+        assert_eq!(i16_val.to_str(), ~"32767");
 
         i16_val += 1 as i16;
-        assert_eq!(i16::to_str(i16_val), ~"-32768");
+        assert_eq!(i16_val.to_str(), ~"-32768");
 
         let mut i32_val: i32 = 2_147_483_647_i32;
-        assert_eq!(i32::to_str(i32_val), ~"2147483647");
+        assert_eq!(i32_val.to_str(), ~"2147483647");
 
         i32_val += 1 as i32;
-        assert_eq!(i32::to_str(i32_val), ~"-2147483648");
+        assert_eq!(i32_val.to_str(), ~"-2147483648");
 
         let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-        assert_eq!(i64::to_str(i64_val), ~"9223372036854775807");
+        assert_eq!(i64_val.to_str(), ~"9223372036854775807");
 
         i64_val += 1 as i64;
-        assert_eq!(i64::to_str(i64_val), ~"-9223372036854775808");
+        assert_eq!(i64_val.to_str(), ~"-9223372036854775808");
     }
 
     #[test]

src/libstd/num/strconv.rs

@@ -708,14 +708,14 @@ mod test {
 mod bench {
     use extra::test::BenchHarness;
     use rand::{XorShiftRng,RngUtil};
-    use uint;
     use float;
+    use to_str::ToStr;
 
     #[bench]
     fn uint_to_str_rand(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();
         do bh.iter {
-            uint::to_str(rng.gen());
+            rng.gen::<uint>().to_str();
         }
     }
 

src/libstd/num/uint_macros.rs

@@ -380,36 +380,26 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: &fn(v: &[u8]) -> U) -> U {
     f(buf.slice(0, cur))
 }
 
+impl ToStr for $T {
     /// Convert to a string in base 10.
     #[inline]
-pub fn to_str(num: $T) -> ~str {
+    fn to_str(&self) -> ~str {
-    to_str_radix(num, 10u)
+        self.to_str_radix(10u)
+    }
 }
 
+impl ToStrRadix for $T {
     /// Convert to a string in a given base.
     #[inline]
-pub fn to_str_radix(num: $T, radix: uint) -> ~str {
+    fn to_str_radix(&self, radix: uint) -> ~str {
         let mut buf = ~[];
-    do strconv::int_to_str_bytes_common(num, radix, strconv::SignNone) |i| {
+        do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNone) |i| {
             buf.push(i);
         }
         // We know we generated valid utf-8, so we don't need to go through that
         // check.
         unsafe { str::raw::from_bytes_owned(buf) }
     }
-
-impl ToStr for $T {
-    #[inline]
-    fn to_str(&self) -> ~str {
-        to_str(*self)
-    }
-}
-
-impl ToStrRadix for $T {
-    #[inline]
-    fn to_str_radix(&self, radix: uint) -> ~str {
-        to_str_radix(*self, radix)
-    }
 }
 
 impl Primitive for $T {
@@ -451,7 +441,6 @@ mod tests {
     use u32;
     use u64;
     use u8;
-    use uint;
 
     #[test]
     fn test_num() {
@@ -536,13 +525,13 @@ mod tests {
 
     #[test]
     pub fn test_to_str() {
-        assert_eq!(to_str_radix(0 as $T, 10u), ~"0");
+        assert_eq!((0 as $T).to_str_radix(10u), ~"0");
-        assert_eq!(to_str_radix(1 as $T, 10u), ~"1");
+        assert_eq!((1 as $T).to_str_radix(10u), ~"1");
-        assert_eq!(to_str_radix(2 as $T, 10u), ~"2");
+        assert_eq!((2 as $T).to_str_radix(10u), ~"2");
-        assert_eq!(to_str_radix(11 as $T, 10u), ~"11");
+        assert_eq!((11 as $T).to_str_radix(10u), ~"11");
-        assert_eq!(to_str_radix(11 as $T, 16u), ~"b");
+        assert_eq!((11 as $T).to_str_radix(16u), ~"b");
-        assert_eq!(to_str_radix(255 as $T, 16u), ~"ff");
+        assert_eq!((255 as $T).to_str_radix(16u), ~"ff");
-        assert_eq!(to_str_radix(0xff as $T, 10u), ~"255");
+        assert_eq!((0xff as $T).to_str_radix(10u), ~"255");
     }
 
     #[test]
@@ -575,28 +564,28 @@ mod tests {
     #[test]
     fn test_uint_to_str_overflow() {
         let mut u8_val: u8 = 255_u8;
-        assert_eq!(u8::to_str(u8_val), ~"255");
+        assert_eq!(u8_val.to_str(), ~"255");
 
         u8_val += 1 as u8;
-        assert_eq!(u8::to_str(u8_val), ~"0");
+        assert_eq!(u8_val.to_str(), ~"0");
 
         let mut u16_val: u16 = 65_535_u16;
-        assert_eq!(u16::to_str(u16_val), ~"65535");
+        assert_eq!(u16_val.to_str(), ~"65535");
 
         u16_val += 1 as u16;
-        assert_eq!(u16::to_str(u16_val), ~"0");
+        assert_eq!(u16_val.to_str(), ~"0");
 
         let mut u32_val: u32 = 4_294_967_295_u32;
-        assert_eq!(u32::to_str(u32_val), ~"4294967295");
+        assert_eq!(u32_val.to_str(), ~"4294967295");
 
         u32_val += 1 as u32;
-        assert_eq!(u32::to_str(u32_val), ~"0");
+        assert_eq!(u32_val.to_str(), ~"0");
 
         let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
-        assert_eq!(u64::to_str(u64_val), ~"18446744073709551615");
+        assert_eq!(u64_val.to_str(), ~"18446744073709551615");
 
         u64_val += 1 as u64;
-        assert_eq!(u64::to_str(u64_val), ~"0");
+        assert_eq!(u64_val.to_str(), ~"0");
     }
 
     #[test]
@@ -638,14 +627,14 @@ mod tests {
     #[should_fail]
     #[ignore(cfg(windows))]
     pub fn to_str_radix1() {
-        uint::to_str_radix(100u, 1u);
+        100u.to_str_radix(1u);
     }
 
     #[test]
     #[should_fail]
     #[ignore(cfg(windows))]
     pub fn to_str_radix37() {
-        uint::to_str_radix(100u, 37u);
+        100u.to_str_radix(37u);
     }
 
     #[test]

src/libstd/prelude.rs

@@ -58,7 +58,7 @@ pub use num::{Orderable, Signed, Unsigned, Round};
 pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
 pub use num::{Integer, Fractional, Real, RealExt};
 pub use num::{Bitwise, BitCount, Bounded};
-pub use num::{Primitive, Int, Float};
+pub use num::{Primitive, Int, Float, ToStrRadix};
 pub use path::GenericPath;
 pub use path::Path;
 pub use path::PosixPath;

src/libstd/unstable/extfmt.rs

@@ -480,7 +480,6 @@ pub mod rt {
     use str;
     use sys;
     use num;
-    use uint;
     use vec;
     use option::{Some, None, Option};
 
@@ -593,7 +592,7 @@ pub mod rt {
         return if prec == 0u && num == 0u {
                 ~""
             } else {
-                let s = uint::to_str_radix(num, radix);
+                let s = num.to_str_radix(radix);
                 let len = s.char_len();
                 if len < prec {
                     let diff = prec - len;

src/libsyntax/print/pprust.rs

@@ -28,7 +28,6 @@ use print::pp;
 use print::pprust;
 
 use std::io;
-use std::u64;
 
 // The @ps is stored here to prevent recursive type.
 pub enum ann_node<'self> {
@@ -2035,24 +2034,24 @@ pub fn print_literal(s: @ps, lit: &ast::lit) {
       ast::lit_int(i, t) => {
         if i < 0_i64 {
             word(s.s,
-                 ~"-" + u64::to_str_radix(-i as u64, 10u)
+                 ~"-" + (-i as u64).to_str_radix(10u)
                  + ast_util::int_ty_to_str(t));
         } else {
             word(s.s,
-                 u64::to_str_radix(i as u64, 10u)
+                 (i as u64).to_str_radix(10u)
                  + ast_util::int_ty_to_str(t));
         }
       }
       ast::lit_uint(u, t) => {
         word(s.s,
-             u64::to_str_radix(u, 10u)
+             u.to_str_radix(10u)
              + ast_util::uint_ty_to_str(t));
       }
       ast::lit_int_unsuffixed(i) => {
         if i < 0_i64 {
-            word(s.s, ~"-" + u64::to_str_radix(-i as u64, 10u));
+            word(s.s, ~"-" + (-i as u64).to_str_radix(10u));
         } else {
-            word(s.s, u64::to_str_radix(i as u64, 10u));
+            word(s.s, (i as u64).to_str_radix(10u));
         }
       }
       ast::lit_float(f, t) => {

src/test/bench/core-set.rs

@@ -89,13 +89,11 @@ impl Results {
             let mut set = f();
             do timed(&mut self.sequential_strings) {
                 for i in range(0u, num_keys) {
-                    let s = uint::to_str(i);
+                    set.insert(i.to_str());
-                    set.insert(s);
                 }
 
                 for i in range(0u, num_keys) {
-                    let s = uint::to_str(i);
+                    assert!(set.contains(&i.to_str()));
-                    assert!(set.contains(&s));
                 }
             }
         }
@@ -104,7 +102,7 @@ impl Results {
             let mut set = f();
             do timed(&mut self.random_strings) {
                 for _ in range(0, num_keys) {
-                    let s = uint::to_str(rng.next() as uint);
+                    let s = (rng.next() as uint).to_str();
                     set.insert(s);
                 }
             }
@@ -113,11 +111,11 @@ impl Results {
         {
             let mut set = f();
             for i in range(0u, num_keys) {
-                set.insert(uint::to_str(i));
+                set.insert(i.to_str());
             }
             do timed(&mut self.delete_strings) {
                 for i in range(0u, num_keys) {
-                    assert!(set.remove(&uint::to_str(i)));
+                    assert!(set.remove(&i.to_str()));
                 }
             }
         }

src/test/bench/core-uint-to-str.rs

@@ -24,7 +24,7 @@ fn main() {
     let n = uint::from_str(args[1]).unwrap();
 
     for i in range(0u, n) {
-        let x = uint::to_str(i);
+        let x = i.to_str();
         info!(x);
     }
 }

src/test/bench/shootout-pfib.rs

@@ -125,7 +125,7 @@ fn main() {
                 let elapsed = stop - start;
 
                 out.write_line(fmt!("%d\t%d\t%s", n, fibn,
-                                    u64::to_str(elapsed)));
+                                    elapsed.to_str()));
             }
         }
     }

src/test/run-pass/monad.rs

@@ -40,7 +40,7 @@ impl<A> option_monad<A> for Option<A> {
 }
 
 fn transform(x: Option<int>) -> Option<~str> {
-    x.bind(|n| Some(*n + 1) ).bind(|n| Some(int::to_str(*n)) )
+    x.bind(|n| Some(*n + 1) ).bind(|n| Some(n.to_str()) )
 }
 
 pub fn main() {

src/test/run-pass/reflect-visit-data.rs

@@ -529,7 +529,7 @@ impl TyVisitor for my_visitor {
     }
     fn visit_int(&self) -> bool {
         do self.get::<int>() |i| {
-            self.vals.push(int::to_str(i));
+            self.vals.push(i.to_str());
         };
         true
     }

src/test/run-pass/static-impl.rs

@@ -32,7 +32,7 @@ trait uint_utils {
 }
 
 impl uint_utils for uint {
-    fn str(&self) -> ~str { uint::to_str(*self) }
+    fn str(&self) -> ~str { self.to_str() }
     fn multi(&self, f: &fn(uint)) {
         let mut c = 0u;
         while c < *self { f(c); c += 1u; }

src/test/run-pass/trait-generic.rs

@@ -13,16 +13,16 @@
 use std::int;
 
 trait to_str {
-    fn to_str(&self) -> ~str;
+    fn to_string(&self) -> ~str;
 }
 impl to_str for int {
-    fn to_str(&self) -> ~str { int::to_str(*self) }
+    fn to_string(&self) -> ~str { self.to_str() }
 }
 impl to_str for ~str {
-    fn to_str(&self) -> ~str { self.clone() }
+    fn to_string(&self) -> ~str { self.clone() }
 }
 impl to_str for () {
-    fn to_str(&self) -> ~str { ~"()" }
+    fn to_string(&self) -> ~str { ~"()" }
 }
 
 trait map<T> {
@@ -43,7 +43,7 @@ fn foo<U, T: map<U>>(x: T) -> ~[~str] {
     x.map(|_e| ~"hi" )
 }
 fn bar<U:to_str,T:map<U>>(x: T) -> ~[~str] {
-    x.map(|_e| _e.to_str() )
+    x.map(|_e| _e.to_string() )
 }
 
 pub fn main() {

src/test/run-pass/trait-to-str.rs

@@ -10,35 +10,26 @@
 
 // xfail-fast
 
-#[no_std];
-
-extern mod std;
-
-use std::str::StrVector;
-use std::vec::ImmutableVector;
-use std::iterator::Iterator;
-use std::int;
-
 trait to_str {
-    fn to_str(&self) -> ~str;
+    fn to_string(&self) -> ~str;
 }
 
 impl to_str for int {
-    fn to_str(&self) -> ~str { int::to_str(*self) }
+    fn to_string(&self) -> ~str { self.to_str() }
 }
 
 impl<T:to_str> to_str for ~[T] {
-    fn to_str(&self) -> ~str {
+    fn to_string(&self) -> ~str {
-        fmt!("[%s]", self.iter().map(|e| e.to_str()).collect::<~[~str]>().connect(", "))
+        fmt!("[%s]", self.iter().map(|e| e.to_string()).collect::<~[~str]>().connect(", "))
     }
 }
 
 pub fn main() {
-    assert!(1.to_str() == ~"1");
+    assert!(1.to_string() == ~"1");
-    assert!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]");
+    assert!((~[2, 3, 4]).to_string() == ~"[2, 3, 4]");
 
     fn indirect<T:to_str>(x: T) -> ~str {
-        x.to_str() + "!"
+        x.to_string() + "!"
     }
     assert!(indirect(~[10, 20]) == ~"[10, 20]!");