librustdoc: fix fallout

src/librustdoc/html/markdown.rs

@@ -32,7 +32,7 @@ use std::ascii::AsciiExt;
 use std::cell::{RefCell, Cell};
 use std::fmt;
 use std::slice;
-use std::str;
+use std::str as str_;
 use std::collections::HashMap;
 
 use html::toc::TocBuilder;
@@ -166,14 +166,14 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
             let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
             let text = slice::from_raw_buf(&(*orig_text).data,
                                            (*orig_text).size as uint);
-            let origtext = str::from_utf8(text).unwrap();
+            let origtext = str_::from_utf8(text).unwrap();
             debug!("docblock: ==============\n{}\n=======", text);
             let rendered = if lang.is_null() {
                 false
             } else {
                 let rlang = slice::from_raw_buf(&(*lang).data,
                                                 (*lang).size as uint);
-                let rlang = str::from_utf8(rlang).unwrap();
+                let rlang = str_::from_utf8(rlang).unwrap();
                 if LangString::parse(rlang).notrust {
                     (my_opaque.dfltblk)(ob, orig_text, lang,
                                         opaque as *mut libc::c_void);
@@ -317,14 +317,14 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
             } else {
                 let lang = slice::from_raw_buf(&(*lang).data,
                                                (*lang).size as uint);
-                let s = str::from_utf8(lang).unwrap();
+                let s = str_::from_utf8(lang).unwrap();
                 LangString::parse(s)
             };
             if block_info.notrust { return }
             let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
             let opaque = opaque as *mut hoedown_html_renderer_state;
             let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
-            let text = str::from_utf8(text).unwrap();
+            let text = str_::from_utf8(text).unwrap();
             let lines = text.lines().map(|l| {
                 stripped_filtered_line(l).unwrap_or(l)
             });
@@ -345,7 +345,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
                 tests.register_header("", level as u32);
             } else {
                 let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
-                let text = str::from_utf8(text).unwrap();
+                let text = str_::from_utf8(text).unwrap();
                 tests.register_header(text, level as u32);
             }
         }

src/librustdoc/html/render.rs

@@ -42,7 +42,7 @@ use std::fmt;
 use std::io::fs::PathExtensions;
 use std::io::{fs, File, BufferedWriter, BufferedReader};
 use std::io;
-use std::str;
+use std::str as str_;
 use std::string::String;
 use std::sync::Arc;
 
@@ -739,7 +739,7 @@ impl<'a> SourceCollector<'a> {
                        filename.ends_with("macros>") => return Ok(()),
             Err(e) => return Err(e)
         };
-        let contents = str::from_utf8(contents.as_slice()).unwrap();
+        let contents = str_::from_utf8(contents.as_slice()).unwrap();
 
         // Remove the utf-8 BOM if any
         let contents = if contents.starts_with("\ufeff") {

src/librustdoc/test.rs

@@ -13,7 +13,7 @@ use std::dynamic_lib::DynamicLibrary;
 use std::io::{Command, TempDir};
 use std::io;
 use std::os;
-use std::str;
+use std::str as str_;
 use std::string::String;
 
 use std::collections::{HashSet, HashMap};
@@ -198,7 +198,7 @@ fn runtest(test: &str, cratename: &str, libs: Vec<Path>, externs: core::Externs,
                 panic!("test executable succeeded when it should have failed");
             } else if !should_fail && !out.status.success() {
                 panic!("test executable failed:\n{}",
-                      str::from_utf8(out.error.as_slice()));
+                      str_::from_utf8(out.error.as_slice()));
             }
         }
     }