Change to_str().to_string() to just to_str()

src/compiletest/errors.rs

@@ -31,7 +31,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
-        let kind = caps.name("kind").to_ascii().to_lower().into_str().to_string();
+        let kind = caps.name("kind").to_ascii().to_lower().into_str();
         let msg = caps.name("msg").trim().to_string();
 
         debug!("line={} kind={} msg={}", line_num, kind, msg);

src/compiletest/util.rs

@@ -41,7 +41,7 @@ pub fn make_new_path(path: &str) -> String {
       Some(curr) => {
         format!("{}{}{}", path, path_div(), curr)
       }
-      None => path.to_str().to_string()
+      None => path.to_str()
     }
 }
 

src/doc/complement-cheatsheet.md

@@ -8,7 +8,7 @@ Use [`ToStr`](std/to_str/trait.ToStr.html).
 
 ~~~
 let x: int = 42;
-let y: String = x.to_str().to_string();
+let y: String = x.to_str();
 ~~~
 
 **String to int**

src/doc/guide-tasks.md

@@ -467,7 +467,7 @@ fn stringifier(channel: &sync::DuplexStream<String, uint>) {
     let mut value: uint;
     loop {
         value = channel.recv();
-        channel.send(value.to_str().to_string());
+        channel.send(value.to_str());
         if value == 0 { break; }
     }
 }
@@ -492,7 +492,7 @@ extern crate sync;
 #     let mut value: uint;
 #     loop {
 #         value = channel.recv();
-#         channel.send(value.to_str().to_string());
+#         channel.send(value.to_str());
 #         if value == 0u { break; }
 #     }
 # }

src/doc/rust.md

@@ -3579,7 +3579,7 @@ trait Printable {
 }
 
 impl Printable for int {
-  fn to_string(&self) -> String { self.to_str().to_string() }
+  fn to_string(&self) -> String { self.to_str() }
 }
 
 fn print(a: Box<Printable>) {

src/libgetopts/lib.rs

@@ -222,7 +222,7 @@ impl Name {
 
     fn to_str(&self) -> String {
         match *self {
-            Short(ch) => ch.to_str().to_string(),
+            Short(ch) => ch.to_str(),
             Long(ref s) => s.to_string()
         }
     }

src/libnum/complex.rs

@@ -349,7 +349,7 @@ mod test {
     #[test]
     fn test_to_str() {
         fn test(c : Complex64, s: String) {
-            assert_eq!(c.to_str().to_string(), s);
+            assert_eq!(c.to_str(), s);
         }
         test(_0_0i, "0+0i".to_string());
         test(_1_0i, "1+0i".to_string());

src/libnum/rational.rs

@@ -559,7 +559,7 @@ mod test {
     fn test_to_from_str() {
         fn test(r: Rational, s: String) {
             assert_eq!(FromStr::from_str(s.as_slice()), Some(r));
-            assert_eq!(r.to_str().to_string(), s);
+            assert_eq!(r.to_str(), s);
         }
         test(_1, "1/1".to_string());
         test(_0, "0/1".to_string());

src/libregex_macros/lib.rs

@@ -611,7 +611,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option<String> {
     let regex = match entry.node {
         ast::ExprLit(lit) => {
             match lit.node {
-                ast::LitStr(ref s, _) => s.to_str().to_string(),
+                ast::LitStr(ref s, _) => s.to_str(),
                 _ => {
                     cx.span_err(entry.span, format!(
                         "expected string literal but got `{}`",

src/librustc/driver/driver.rs

@@ -533,15 +533,15 @@ impl pprust::PpAnn for IdentifiedAnnotation {
         match node {
             pprust::NodeItem(item) => {
                 try!(pp::space(&mut s.s));
-                s.synth_comment(item.id.to_str().to_string())
+                s.synth_comment(item.id.to_str())
             }
             pprust::NodeBlock(blk) => {
                 try!(pp::space(&mut s.s));
                 s.synth_comment((format!("block {}", blk.id)).to_string())
             }
             pprust::NodeExpr(expr) => {
                 try!(pp::space(&mut s.s));
-                try!(s.synth_comment(expr.id.to_str().to_string()));
+                try!(s.synth_comment(expr.id.to_str()));
                 s.pclose()
             }
             pprust::NodePat(pat) => {

src/librustc/middle/liveness.rs

@@ -324,7 +324,7 @@ impl<'a> IrMaps<'a> {
     fn variable_name(&self, var: Variable) -> String {
         match self.var_kinds.get(var.get()) {
             &Local(LocalInfo { ident: nm, .. }) | &Arg(_, nm) => {
-                token::get_ident(nm).get().to_str().to_string()
+                token::get_ident(nm).get().to_str()
             },
             &ImplicitRet => "<implicit-ret>".to_string()
         }

src/librustc/middle/mem_categorization.rs

@@ -1303,7 +1303,7 @@ impl Repr for InteriorKind {
     fn repr(&self, _tcx: &ty::ctxt) -> String {
         match *self {
             InteriorField(NamedField(fld)) => {
-                token::get_name(fld).get().to_str().to_string()
+                token::get_name(fld).get().to_str()
             }
             InteriorField(PositionalField(i)) => format!("\\#{:?}", i),
             InteriorElement(_) => "[]".to_string(),

src/librustc/middle/trans/base.rs

@@ -1927,7 +1927,7 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId,
         _ => ccx.tcx.map.with_path(id, |mut path| {
             if attr::contains_name(attrs, "no_mangle") {
                 // Don't mangle
-                path.last().unwrap().to_str().to_string()
+                path.last().unwrap().to_str()
             } else {
                 match weak_lang_items::link_name(attrs) {
                     Some(name) => name.get().to_string(),

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

@@ -79,13 +79,13 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
 
 impl InferStr for IntVarValue {
     fn inf_str(&self, _cx: &InferCtxt) -> String {
-        self.to_str().to_string()
+        self.to_str()
     }
 }
 
 impl InferStr for ast::FloatTy {
     fn inf_str(&self, _cx: &InferCtxt) -> String {
-        self.to_str().to_string()
+        self.to_str()
     }
 }
 

src/librustc/util/ppaux.rs

@@ -366,7 +366,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> String {
       ty_bare_fn(ref f) => {
           bare_fn_to_str(cx, f.fn_style, f.abi, None, &f.sig)
       }
-      ty_infer(infer_ty) => infer_ty.to_str().to_string(),
+      ty_infer(infer_ty) => infer_ty.to_str(),
       ty_err => "[type error]".to_string(),
       ty_param(param_ty {idx: id, def_id: did}) => {
           let ident = match cx.ty_param_defs.borrow().find(&did.node) {
@@ -753,7 +753,10 @@ impl Repr for ty::ItemVariances {
 
 impl Repr for ty::Variance {
     fn repr(&self, _: &ctxt) -> String {
-        self.to_str().to_string()
+        // The first `.to_str()` returns a &'static str (it is not an implementation
+        // of the ToStr trait). Because of that, we need to call `.to_str()` again
+        // if we want to have a `String`.
+        self.to_str().to_str()
     }
 }
 
@@ -950,13 +953,13 @@ impl UserString for ast::Ident {
 
 impl Repr for abi::Abi {
     fn repr(&self, _tcx: &ctxt) -> String {
-        self.to_str().to_string()
+        self.to_str()
     }
 }
 
 impl UserString for abi::Abi {
     fn user_string(&self, _tcx: &ctxt) -> String {
-        self.to_str().to_string()
+        self.to_str()
     }
 }
 

src/librustdoc/clean/inline.rs

@@ -93,7 +93,7 @@ fn try_inline_def(cx: &core::DocContext,
     cx.inlined.borrow_mut().get_mut_ref().insert(did);
     ret.push(clean::Item {
         source: clean::Span::empty(),
-        name: Some(fqn.last().unwrap().to_str().to_string()),
+        name: Some(fqn.last().unwrap().to_str()),
         attrs: load_attrs(tcx, did),
         inner: inner,
         visibility: Some(ast::Public),

src/librustdoc/clean/mod.rs

@@ -526,7 +526,7 @@ impl Clean<TyParamBound> for ty::BuiltinBound {
                  external_path("Share", &empty)),
         };
         let fqn = csearch::get_item_path(tcx, did);
-        let fqn = fqn.move_iter().map(|i| i.to_str().to_string()).collect();
+        let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
         cx.external_paths.borrow_mut().get_mut_ref().insert(did,
                                                             (fqn, TypeTrait));
         TraitBound(ResolvedPath {
@@ -545,7 +545,7 @@ impl Clean<TyParamBound> for ty::TraitRef {
             core::NotTyped(_) => return RegionBound,
         };
         let fqn = csearch::get_item_path(tcx, self.def_id);
-        let fqn = fqn.move_iter().map(|i| i.to_str().to_string())
+        let fqn = fqn.move_iter().map(|i| i.to_str())
                      .collect::<Vec<String>>();
         let path = external_path(fqn.last().unwrap().as_slice(),
                                  &self.substs);
@@ -1239,7 +1239,7 @@ impl Clean<Type> for ty::t {
                 };
                 let fqn = csearch::get_item_path(tcx, did);
                 let fqn: Vec<String> = fqn.move_iter().map(|i| {
-                    i.to_str().to_string()
+                    i.to_str()
                 }).collect();
                 let kind = match ty::get(*self).sty {
                     ty::ty_struct(..) => TypeStruct,
@@ -1617,7 +1617,7 @@ impl Clean<BareFunctionDecl> for ast::BareFnTy {
                 type_params: Vec::new(),
             },
             decl: self.decl.clean(),
-            abi: self.abi.to_str().to_string(),
+            abi: self.abi.to_str(),
         }
     }
 }
@@ -1891,12 +1891,12 @@ fn lit_to_str(lit: &ast::Lit) -> String {
         ast::LitStr(ref st, _) => st.get().to_string(),
         ast::LitBinary(ref data) => format!("{:?}", data.as_slice()),
         ast::LitChar(c) => format!("'{}'", c),
-        ast::LitInt(i, _t) => i.to_str().to_string(),
-        ast::LitUint(u, _t) => u.to_str().to_string(),
-        ast::LitIntUnsuffixed(i) => i.to_str().to_string(),
+        ast::LitInt(i, _t) => i.to_str(),
+        ast::LitUint(u, _t) => u.to_str(),
+        ast::LitIntUnsuffixed(i) => i.to_str(),
         ast::LitFloat(ref f, _t) => f.get().to_string(),
         ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),
-        ast::LitBool(b) => b.to_str().to_string(),
+        ast::LitBool(b) => b.to_str(),
         ast::LitNil => "".to_string(),
     }
 }

src/librustdoc/html/format.rs

@@ -401,7 +401,7 @@ impl fmt::Show for clean::Type {
                        } else {
                            let mut m = decl.bounds
                                            .iter()
-                                           .map(|s| s.to_str().to_string());
+                                           .map(|s| s.to_str());
                            format!(
                                ": {}",
                                m.collect::<Vec<String>>().connect(" + "))

src/librustdoc/html/markdown.rs

@@ -208,7 +208,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
         // Transform the contents of the header into a hyphenated string
         let id = (s.as_slice().words().map(|s| {
             match s.to_ascii_opt() {
-                Some(s) => s.to_lower().into_str().to_string(),
+                Some(s) => s.to_lower().into_str(),
                 None => s.to_string()
             }
         }).collect::<Vec<String>>().connect("-")).to_string();

src/librustdoc/lib.rs

@@ -360,7 +360,7 @@ fn json_input(input: &str) -> Result<Output, String> {
         }
     };
     match json::from_reader(&mut input) {
-        Err(s) => Err(s.to_str().to_string()),
+        Err(s) => Err(s.to_str()),
         Ok(json::Object(obj)) => {
             let mut obj = obj;
             // Make sure the schema is what we expect

src/libsyntax/ext/source_util.rs

@@ -125,7 +125,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
         Some(src) => {
             // Add this input file to the code map to make it available as
             // dependency information
-            let filename = file.display().to_str().to_string();
+            let filename = file.display().to_str();
             let interned = token::intern_and_get_ident(src);
             cx.codemap().new_filemap(filename, src.to_string());
 

src/libsyntax/ext/tt/macro_rules.rs

@@ -252,7 +252,7 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
 
     box MacroRulesDefiner {
         def: RefCell::new(Some(MacroDef {
-            name: token::get_ident(name).to_str().to_string(),
+            name: token::get_ident(name).to_str(),
             ext: NormalTT(exp, Some(sp))
         }))
     } as Box<MacResult>

src/libsyntax/parse/token.rs

@@ -205,7 +205,7 @@ pub fn to_str(t: &Token) -> String {
                                                ast_util::ForceSuffix),
       LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u),
                                                  ast_util::ForceSuffix),
-      LIT_INT_UNSUFFIXED(i) => { (i as u64).to_str().to_string() }
+      LIT_INT_UNSUFFIXED(i) => { (i as u64).to_str() }
       LIT_FLOAT(s, t) => {
         let mut body = String::from_str(get_ident(s).get());
         if body.as_slice().ends_with(".") {

src/libtest/lib.rs

@@ -1503,7 +1503,7 @@ mod tests {
         let filtered = filter_tests(&opts, tests);
 
         assert_eq!(filtered.len(), 1);
-        assert_eq!(filtered.get(0).desc.name.to_str().to_string(),
+        assert_eq!(filtered.get(0).desc.name.to_str(),
                    "1".to_string());
         assert!(filtered.get(0).desc.ignore == false);
     }
@@ -1554,7 +1554,7 @@ mod tests {
                  "test::sort_tests".to_string());
 
         for (a, b) in expected.iter().zip(filtered.iter()) {
-            assert!(*a == b.desc.name.to_str().to_string());
+            assert!(*a == b.desc.name.to_str());
         }
     }
 

src/libtime/lib.rs

@@ -1020,7 +1020,7 @@ pub fn strftime(format: &str, tm: &Tm) -> String {
           'U' => format!("{:02d}", (tm.tm_yday - tm.tm_wday + 7) / 7),
           'u' => {
             let i = tm.tm_wday as int;
-            (if i == 0 { 7 } else { i }).to_str().to_string()
+            (if i == 0 { 7 } else { i }).to_str()
           }
           'V' => iso_week('V', tm),
           'v' => {
@@ -1033,8 +1033,8 @@ pub fn strftime(format: &str, tm: &Tm) -> String {
               format!("{:02d}",
                              (tm.tm_yday - (tm.tm_wday - 1 + 7) % 7 + 7) / 7)
           }
-          'w' => (tm.tm_wday as int).to_str().to_string(),
-          'Y' => (tm.tm_year as int + 1900).to_str().to_string(),
+          'w' => (tm.tm_wday as int).to_str(),
+          'Y' => (tm.tm_year as int + 1900).to_str(),
           'y' => format!("{:02d}", (tm.tm_year as int + 1900) % 100),
           'Z' => "".to_string(),    // FIXME(pcwalton): Implement this.
           'z' => {

src/liburl/lib.rs

@@ -527,7 +527,7 @@ fn get_authority(rawurl: &str) ->
     Result<(Option<UserInfo>, String, Option<String>, String), String> {
     if !rawurl.starts_with("//") {
         // there is no authority.
-        return Ok((None, "".to_string(), None, rawurl.to_str().to_string()));
+        return Ok((None, "".to_string(), None, rawurl.to_str()));
     }
 
     enum State {

src/test/bench/core-set.rs

@@ -90,11 +90,11 @@ impl Results {
             let mut set = f();
             timed(&mut self.sequential_strings, || {
                 for i in range(0u, num_keys) {
-                    set.insert(i.to_str().to_string());
+                    set.insert(i.to_str());
                 }
 
                 for i in range(0u, num_keys) {
-                    assert!(set.contains(&i.to_str().to_string()));
+                    assert!(set.contains(&i.to_str()));
                 }
             })
         }
@@ -103,7 +103,7 @@ impl Results {
             let mut set = f();
             timed(&mut self.random_strings, || {
                 for _ in range(0, num_keys) {
-                    let s = rng.gen::<uint>().to_str().to_string();
+                    let s = rng.gen::<uint>().to_str();
                     set.insert(s);
                 }
             })
@@ -112,11 +112,11 @@ impl Results {
         {
             let mut set = f();
             for i in range(0u, num_keys) {
-                set.insert(i.to_str().to_string());
+                set.insert(i.to_str());
             }
             timed(&mut self.delete_strings, || {
                 for i in range(0u, num_keys) {
-                    assert!(set.remove(&i.to_str().to_string()));
+                    assert!(set.remove(&i.to_str()));
                 }
             })
         }

src/test/run-pass/monad.rs

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