std: remove str::contains in favour of the method

Author: huonw

doc/rust.md

@@ -802,20 +802,15 @@ Use declarations support a number of convenient shortcuts:
 An example of `use` declarations:
 
 ~~~~
-use std::float::sin;
-use std::str::{from_chars, contains};
+use std::float::{sin, pow};
 use std::option::Some;
 
 fn main() {
-    // Equivalent to 'info!(std::float::sin(1.0));'
-    info!(sin(1.0));
+    // Equivalent to 'info!(std::float::pow(std::float::sin(1.0), 2.0));'
+    info!(pow(sin(1.0), 2.0));
 
     // Equivalent to 'info!(std::option::Some(1.0));'
     info!(Some(1.0));
-
-    // Equivalent to
-    // 'info!(std::str::contains(std::str::from_chars(&['f','o','o']), "oo"));'
-    info!(contains(from_chars(&['f','o','o']), "oo"));
 }
 ~~~~
 

src/compiletest/header.rs

@@ -169,7 +169,7 @@ fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
 }
 
 fn parse_name_directive(line: &str, directive: &str) -> bool {
-    str::contains(line, directive)
+    line.contains(directive)
 }
 
 fn parse_name_value_directive(line: &str,

src/compiletest/runtest.rs

@@ -309,7 +309,7 @@ fn check_error_patterns(props: &TestProps,
     let mut next_err_pat = &props.error_patterns[next_err_idx];
     let mut done = false;
     for ProcRes.stderr.line_iter().advance |line| {
-        if str::contains(line, *next_err_pat) {
+        if line.contains(*next_err_pat) {
             debug!("found error pattern %s", *next_err_pat);
             next_err_idx += 1u;
             if next_err_idx == props.error_patterns.len() {
@@ -365,8 +365,8 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
                 debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
                        prefixes[i], ee.kind, ee.msg, line);
                 if (str::starts_with(line, prefixes[i]) &&
-                    str::contains(line, ee.kind) &&
-                    str::contains(line, ee.msg)) {
+                    line.contains(ee.kind) &&
+                    line.contains(ee.msg)) {
                     found_flags[i] = true;
                     was_expected = true;
                     break;
@@ -375,7 +375,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         }
 
         // ignore this msg which gets printed at the end
-        if str::contains(line, "aborting due to") {
+        if line.contains("aborting due to") {
             was_expected = true;
         }
 

src/libextra/net_tcp.rs

@@ -1597,8 +1597,8 @@ mod test {
                        expected_req, actual_req);
         debug!("RESP: expected: '%s' actual: '%s'",
                        expected_resp, actual_resp);
-        assert!(str::contains(actual_req, expected_req));
-        assert!(str::contains(actual_resp, expected_resp));
+        assert!(actual_req.contains(expected_req));
+        assert!(actual_resp.contains(expected_resp));
     }
     pub fn impl_gl_tcp_ipv4_get_peer_addr() {
         let hl_loop = &uv::global_loop::get();
@@ -1765,8 +1765,8 @@ mod test {
                        expected_req, actual_req);
         debug!("RESP: expected: '%s' actual: '%s'",
                        expected_resp, actual_resp);
-        assert!(str::contains(actual_req, expected_req));
-        assert!(str::contains(actual_resp, expected_resp));
+        assert!(actual_req.contains(expected_req));
+        assert!(actual_resp.contains(expected_resp));
     }
 
     pub fn impl_tcp_socket_impl_reader_handles_eof() {

src/libextra/test.rs

@@ -514,7 +514,7 @@ pub fn filter_tests(
 
         fn filter_fn(test: TestDescAndFn, filter_str: &str) ->
             Option<TestDescAndFn> {
-            if str::contains(test.desc.name.to_str(), filter_str) {
+            if test.desc.name.to_str().contains(filter_str) {
                 return option::Some(test);
             } else { return option::None; }
         }

src/libextra/uv_ll.rs

@@ -1480,7 +1480,7 @@ mod test {
 
                 let server_kill_msg = copy (*client_data).server_kill_msg;
                 let write_req = (*client_data).server_write_req;
-                if str::contains(request_str, server_kill_msg) {
+                if request_str.contains(server_kill_msg) {
                     debug!(~"SERVER: client req contains kill_msg!");
                     debug!(~"SERVER: sending response to client");
                     read_stop(client_stream_ptr);
@@ -1753,8 +1753,8 @@ mod test {
         let msg_from_client = server_port.recv();
         let msg_from_server = client_port.recv();
 
-        assert!(str::contains(msg_from_client, kill_server_msg));
-        assert!(str::contains(msg_from_server, server_resp_msg));
+        assert!(msg_from_client.contains(kill_server_msg));
+        assert!(msg_from_server.contains(server_resp_msg));
     }
 
     // FIXME don't run on fbsd or linux 32 bit(#2064)

src/libfuzzer/fuzzer.rc

@@ -57,7 +57,7 @@ pub fn write_file(filename: &Path, content: &str) {
 }
 
 pub fn contains(haystack: &str, needle: &str) -> bool {
-    str::contains(haystack, needle)
+    haystack.contains(needle)
 }
 
 pub fn find_rust_files(files: &mut ~[Path], path: &Path) {

src/librustc/driver/driver.rs

@@ -465,33 +465,33 @@ pub fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: &input,
 }
 
 pub fn get_os(triple: &str) -> Option<session::os> {
-    if str::contains(triple, "win32") ||
-               str::contains(triple, "mingw32") {
+    if triple.contains("win32") ||
+               triple.contains("mingw32") {
             Some(session::os_win32)
-        } else if str::contains(triple, "darwin") {
+        } else if triple.contains("darwin") {
             Some(session::os_macos)
-        } else if str::contains(triple, "android") {
+        } else if triple.contains("android") {
             Some(session::os_android)
-        } else if str::contains(triple, "linux") {
+        } else if triple.contains("linux") {
             Some(session::os_linux)
-        } else if str::contains(triple, "freebsd") {
+        } else if triple.contains("freebsd") {
             Some(session::os_freebsd)
         } else { None }
 }
 
 pub fn get_arch(triple: &str) -> Option<abi::Architecture> {
-    if str::contains(triple, "i386") ||
-        str::contains(triple, "i486") ||
-               str::contains(triple, "i586") ||
-               str::contains(triple, "i686") ||
-               str::contains(triple, "i786") {
+    if triple.contains("i386") ||
+        triple.contains("i486") ||
+               triple.contains("i586") ||
+               triple.contains("i686") ||
+               triple.contains("i786") {
             Some(abi::X86)
-        } else if str::contains(triple, "x86_64") {
+        } else if triple.contains("x86_64") {
             Some(abi::X86_64)
-        } else if str::contains(triple, "arm") ||
-                      str::contains(triple, "xscale") {
+        } else if triple.contains("arm") ||
+                      triple.contains("xscale") {
             Some(abi::Arm)
-        } else if str::contains(triple, "mips") {
+        } else if triple.contains("mips") {
             Some(abi::Mips)
         } else { None }
 }

src/librustc/middle/resolve.rs

@@ -3099,7 +3099,7 @@ impl Resolver {
         let import_count = imports.len();
         if index != import_count {
             let sn = self.session.codemap.span_to_snippet(imports[index].span);
-            if str::contains(sn, "::") {
+            if sn.contains("::") {
                 self.session.span_err(imports[index].span, "unresolved import");
             } else {
                 let err = fmt!("unresolved import (maybe you meant `%s::*`?)",