Fix run-pass tests

src/test/auxiliary/lang-item-public.rs

@@ -14,6 +14,9 @@
 #[lang="sized"]
 pub trait Sized for Sized? {}
 
+#[lang="str"]
+struct str([u8]);
+
 #[lang="panic"]
 fn panic(_: &(&'static str, &'static str, uint)) -> ! { loop {} }
 

src/test/auxiliary/weak-lang-items.rs

@@ -32,6 +32,6 @@ pub fn foo() {
 }
 
 mod std {
-    pub use core::{option, fmt};
+    pub use core::{option, fmt, str};
 }
 

src/test/run-pass/backtrace.rs

@@ -13,7 +13,7 @@
 use std::os;
 use std::io::process::Command;
 use std::finally::Finally;
-use std::str;
+use std::str as str_;
 
 #[inline(never)]
 fn foo() {
@@ -40,23 +40,23 @@ fn runtest(me: &str) {
     let p = template.clone().arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(out.error.as_slice()).unwrap();
+    let s = str_::from_utf8(out.error.as_slice()).unwrap();
     assert!(s.contains("stack backtrace") && s.contains("foo::h"),
             "bad output: {}", s);
 
     // Make sure the stack trace is *not* printed
     let p = template.clone().arg("fail").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(out.error.as_slice()).unwrap();
+    let s = str_::from_utf8(out.error.as_slice()).unwrap();
     assert!(!s.contains("stack backtrace") && !s.contains("foo::h"),
             "bad output2: {}", s);
 
     // Make sure a stack trace is printed
     let p = template.clone().arg("double-fail").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(out.error.as_slice()).unwrap();
+    let s = str_::from_utf8(out.error.as_slice()).unwrap();
     // loosened the following from double::h to double:: due to
     // spurious failures on mac, 32bit, optimized
     assert!(s.contains("stack backtrace") && s.contains("double::"),
@@ -67,7 +67,7 @@ fn runtest(me: &str) {
                                 .env("RUST_BACKTRACE", "1").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(out.error.as_slice()).unwrap();
+    let s = str_::from_utf8(out.error.as_slice()).unwrap();
     let mut i = 0;
     for _ in range(0i, 2) {
         i += s.slice_from(i + 10).find_str("stack backtrace").unwrap() + 10;

src/test/run-pass/core-run-destroy.rs

@@ -22,7 +22,6 @@ extern crate libc;
 
 use std::io::{Process, Command, timer};
 use std::time::Duration;
-use std::str;
 
 macro_rules! succeed( ($e:expr) => (
     match $e { Ok(..) => {}, Err(e) => panic!("panic: {}", e) }
@@ -58,7 +57,6 @@ pub fn test_destroy_actually_kills(force: bool) {
     use std::io::process::{Command, ProcessOutput, ExitStatus, ExitSignal};
     use std::io::timer;
     use libc;
-    use std::str;
 
     #[cfg(all(unix,not(target_os="android")))]
     static BLOCK_COMMAND: &'static str = "cat";

src/test/run-pass/foreign-fn-linkname.rs

@@ -22,9 +22,9 @@ mod mlibc {
     }
 }
 
-fn strlen(str: String) -> uint {
+fn strlen(s: String) -> uint {
     // C string is terminated with a zero
-    str.as_slice().with_c_str(|buf| {
+    s.as_slice().with_c_str(|buf| {
         unsafe {
             mlibc::my_strlen(buf) as uint
         }

src/test/run-pass/issue-18353.rs

@@ -16,6 +16,6 @@ struct Str {
 }
 
 fn main() {
-    let str: Option<&Str> = None;
-    str.is_some();
+    let s: Option<&Str> = None;
+    s.is_some();
 }

src/test/run-pass/move-out-of-field.rs

@@ -30,6 +30,6 @@ pub fn main() {
     };
     sb.append("Hello, ");
     sb.append("World!");
-    let str = to_string(sb);
-    assert_eq!(str.as_slice(), "Hello, World!");
+    let s = to_string(sb);
+    assert_eq!(s.as_slice(), "Hello, World!");
 }