librustdoc: Remove all ~str usage from librustdoc.

Author: pcwalton

src/librustdoc/clean.rs

@@ -32,7 +32,7 @@ pub enum MaybeTyped {
 }
 
 pub type ExternalPaths = RefCell<Option<HashMap<ast::DefId,
-                                                (Vec<~str>, clean::TypeKind)>>>;
+                                                (Vec<StrBuf>, clean::TypeKind)>>>;
 
 pub struct DocContext {
     pub krate: ast::Crate,
@@ -57,7 +57,7 @@ pub struct CrateAnalysis {
 }
 
 /// Parses, resolves, and typechecks the given crate
-fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
+fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<StrBuf>)
                        -> (DocContext, CrateAnalysis) {
     use syntax::codemap::dummy_spanned;
     use rustc::driver::driver::{FileInput,
@@ -88,7 +88,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
 
     let mut cfg = build_configuration(&sess);
     for cfg_ in cfgs.move_iter() {
-        let cfg_ = token::intern_and_get_ident(cfg_);
+        let cfg_ = token::intern_and_get_ident(cfg_.as_slice());
         cfg.push(@dummy_spanned(ast::MetaWord(cfg_)));
     }
 
@@ -112,7 +112,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
     })
 }
 
-pub fn run_core(libs: HashSet<Path>, cfgs: Vec<~str>, path: &Path)
+pub fn run_core(libs: HashSet<Path>, cfgs: Vec<StrBuf>, path: &Path)
                 -> (clean::Crate, CrateAnalysis) {
     let (ctxt, analysis) = get_ast_and_resolve(path, libs, cfgs);
     let ctxt = @ctxt;

src/librustdoc/core.rs

@@ -151,11 +151,13 @@ fn resolved_path(w: &mut io::Writer, did: ast::DefId, p: &clean::Path,
     path(w, p, print_all,
         |cache, loc| {
             if ast_util::is_local(did) {
-                Some("../".repeat(loc.len()))
+                Some(("../".repeat(loc.len())).to_strbuf())
             } else {
                 match *cache.extern_locations.get(&did.krate) {
-                    render::Remote(ref s) => Some(s.clone()),
-                    render::Local => Some("../".repeat(loc.len())),
+                    render::Remote(ref s) => Some(s.to_strbuf()),
+                    render::Local => {
+                        Some(("../".repeat(loc.len())).to_strbuf())
+                    }
                     render::Unknown => None,
                 }
             }
@@ -169,8 +171,8 @@ fn resolved_path(w: &mut io::Writer, did: ast::DefId, p: &clean::Path,
 }
 
 fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
-        root: |&render::Cache, &[~str]| -> Option<~str>,
-        info: |&render::Cache| -> Option<(Vec<~str> , ItemType)>)
+        root: |&render::Cache, &[StrBuf]| -> Option<StrBuf>,
+        info: |&render::Cache| -> Option<(Vec<StrBuf> , ItemType)>)
     -> fmt::Result
 {
     // The generics will get written to both the title and link
@@ -206,10 +208,11 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
             Some(root) => {
                 let mut root = StrBuf::from_str(root);
                 for seg in path.segments.slice_to(amt).iter() {
-                    if "super" == seg.name || "self" == seg.name {
+                    if "super" == seg.name.as_slice() ||
+                            "self" == seg.name.as_slice() {
                         try!(write!(w, "{}::", seg.name));
                     } else {
-                        root.push_str(seg.name);
+                        root.push_str(seg.name.as_slice());
                         root.push_str("/");
                         try!(write!(w, "<a class='mod'
                                             href='{}index.html'>{}</a>::",
@@ -229,21 +232,21 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
     match info(&**cache) {
         // This is a documented path, link to it!
         Some((ref fqp, shortty)) if abs_root.is_some() => {
-            let mut url = StrBuf::from_str(abs_root.unwrap());
+            let mut url = StrBuf::from_str(abs_root.unwrap().as_slice());
             let to_link = fqp.slice_to(fqp.len() - 1);
             for component in to_link.iter() {
-                url.push_str(*component);
+                url.push_str(component.as_slice());
                 url.push_str("/");
             }
             match shortty {
                 item_type::Module => {
-                    url.push_str(*fqp.last().unwrap());
+                    url.push_str(fqp.last().unwrap().as_slice());
                     url.push_str("/index.html");
                 }
                 _ => {
                     url.push_str(shortty.to_static_str());
                     url.push_str(".");
-                    url.push_str(*fqp.last().unwrap());
+                    url.push_str(fqp.last().unwrap().as_slice());
                     url.push_str(".html");
                 }
             }
@@ -352,16 +355,20 @@ impl fmt::Show for clean::Type {
                                {arrow, select, yes{ -&gt; {ret}} other{}}",
                        style = FnStyleSpace(decl.fn_style),
                        lifetimes = if decl.lifetimes.len() == 0 {
-                           "".to_owned()
+                           "".to_strbuf()
                        } else {
-                           format!("&lt;{:#}&gt;", decl.lifetimes)
+                           format_strbuf!("&lt;{:#}&gt;", decl.lifetimes)
                        },
                        args = decl.decl.inputs,
                        bounds = if decl.bounds.len() == 0 {
-                           "".to_owned()
+                           "".to_strbuf()
                        } else {
-                           let mut m = decl.bounds.iter().map(|s| s.to_str());
-                           ": " + m.collect::<Vec<~str>>().connect(" + ")
+                           let mut m = decl.bounds
+                                           .iter()
+                                           .map(|s| s.to_str().to_strbuf());
+                           format_strbuf!(
+                               ": {}",
+                               m.collect::<Vec<StrBuf>>().connect(" + "))
                        },
                        arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
                        ret = decl.decl.output)
@@ -370,9 +377,9 @@ impl fmt::Show for clean::Type {
                 write!(f.buf, "{}{}fn{}{}",
                        FnStyleSpace(decl.fn_style),
                        match decl.abi.as_slice() {
-                           "" => " extern ".to_owned(),
-                           "\"Rust\"" => "".to_owned(),
-                           s => format!(" extern {} ", s)
+                           "" => " extern ".to_strbuf(),
+                           "\"Rust\"" => "".to_strbuf(),
+                           s => format_strbuf!(" extern {} ", s)
                        },
                        decl.generics,
                        decl.decl)

src/librustdoc/html/format.rs

@@ -25,7 +25,7 @@ use html::escape::Escape;
 use t = syntax::parse::token;
 
 /// Highlights some source code, returning the HTML output.
-pub fn highlight(src: &str, class: Option<&str>) -> ~str {
+pub fn highlight(src: &str, class: Option<&str>) -> StrBuf {
     let sess = parse::new_parse_sess();
     let fm = parse::string_to_filemap(&sess,
                                       src.to_strbuf(),
@@ -36,7 +36,7 @@ pub fn highlight(src: &str, class: Option<&str>) -> ~str {
          lexer::new_string_reader(&sess.span_diagnostic, fm),
          class,
          &mut out).unwrap();
-    str::from_utf8_lossy(out.unwrap().as_slice()).into_owned()
+    str::from_utf8_lossy(out.unwrap().as_slice()).to_strbuf()
 }
 
 /// Exhausts the `lexer` writing the output into `out`.

src/librustdoc/html/highlight.rs

@@ -13,9 +13,9 @@ use std::io;
 
 #[deriving(Clone)]
 pub struct Layout {
-    pub logo: ~str,
-    pub favicon: ~str,
-    pub krate: ~str,
+    pub logo: StrBuf,
+    pub favicon: StrBuf,
+    pub krate: StrBuf,
 }
 
 pub struct Page<'a> {
@@ -119,9 +119,9 @@ r##"<!DOCTYPE html>
     content   = *t,
     root_path = page.root_path,
     ty        = page.ty,
-    logo      = nonestr(layout.logo),
+    logo      = nonestr(layout.logo.as_slice()),
     title     = page.title,
-    favicon   = nonestr(layout.favicon),
+    favicon   = nonestr(layout.favicon.as_slice()),
     sidebar   = *sidebar,
     krate     = layout.krate,
     )

src/librustdoc/html/layout.rs

@@ -139,7 +139,7 @@ fn stripped_filtered_line<'a>(s: &'a str) -> Option<&'a str> {
     }
 }
 
-local_data_key!(used_header_map: RefCell<HashMap<~str, uint>>)
+local_data_key!(used_header_map: RefCell<HashMap<StrBuf, uint>>)
 
 pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
     extern fn block(ob: *mut hoedown_buffer, text: *hoedown_buffer,
@@ -177,7 +177,8 @@ pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
                 };
 
                 if !rendered {
-                    let output = highlight::highlight(text, None).to_c_str();
+                    let output = highlight::highlight(text, None).as_slice()
+                                                                 .to_c_str();
                     output.with_ref(|r| {
                         hoedown_buffer_puts(ob, r)
                     })
@@ -201,16 +202,16 @@ pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
         };
 
         // Transform the contents of the header into a hyphenated string
-        let id = s.words().map(|s| {
+        let id = (s.words().map(|s| {
             match s.to_ascii_opt() {
-                Some(s) => s.to_lower().into_str(),
-                None => s.to_owned()
+                Some(s) => s.to_lower().into_str().to_strbuf(),
+                None => s.to_strbuf()
             }
-        }).collect::<Vec<~str>>().connect("-");
+        }).collect::<Vec<StrBuf>>().connect("-")).to_strbuf();
 
         // This is a terrible hack working around how hoedown gives us rendered
         // html for text rather than the raw text.
-        let id = id.replace("<code>", "").replace("</code>", "");
+        let id = id.replace("<code>", "").replace("</code>", "").to_strbuf();
 
         let opaque = opaque as *mut hoedown_html_renderer_state;
         let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
@@ -219,13 +220,13 @@ pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
         let map = used_header_map.get().unwrap();
         let id = match map.borrow_mut().find_mut(&id) {
             None => id,
-            Some(a) => { *a += 1; format!("{}-{}", id, *a - 1) }
+            Some(a) => { *a += 1; format_strbuf!("{}-{}", id, *a - 1) }
         };
         map.borrow_mut().insert(id.clone(), 1);
 
         let sec = match opaque.toc_builder {
             Some(ref mut builder) => {
-                builder.push(level as u32, s.clone(), id.clone())
+                builder.push(level as u32, s.to_strbuf(), id.clone())
             }
             None => {""}
         };
@@ -298,7 +299,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
                     stripped_filtered_line(l).unwrap_or(l)
                 });
                 let text = lines.collect::<Vec<&str>>().connect("\n");
-                tests.add_test(text, should_fail, no_run, ignore);
+                tests.add_test(text.to_strbuf(), should_fail, no_run, ignore);
             })
         }
     }