From a64e886e3c1dd38473fd7711933557f1b97a9036 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Mon, 10 Jun 2013 17:32:36 +1000 Subject: [PATCH] std: remove str::contains in favour of the method --- doc/rust.md | 11 +--- src/compiletest/header.rs | 2 +- src/compiletest/runtest.rs | 8 +-- src/libextra/net_tcp.rs | 8 +-- src/libextra/test.rs | 2 +- src/libextra/uv_ll.rs | 6 +- src/libfuzzer/fuzzer.rc | 2 +- src/librustc/driver/driver.rs | 30 +++++----- src/librustc/middle/resolve.rs | 2 +- src/librustdoc/markdown_pass.rs | 86 ++++++++++++++--------------- src/librustdoc/sectionalize_pass.rs | 16 ++---- src/libstd/str.rs | 66 +++++++++------------- 12 files changed, 104 insertions(+), 135 deletions(-) diff --git a/doc/rust.md b/doc/rust.md index 6d586c9b201..0a33eb6ab2a 100644 --- a/doc/rust.md +++ b/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")); } ~~~~ diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 0adcb924a49..d8562d725a7 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -169,7 +169,7 @@ fn parse_pp_exact(line: &str, testfile: &Path) -> Option { } fn parse_name_directive(line: &str, directive: &str) -> bool { - str::contains(line, directive) + line.contains(directive) } fn parse_name_value_directive(line: &str, diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 8f493fa2d06..d87101ffb85 100644 --- a/src/compiletest/runtest.rs +++ b/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; } diff --git a/src/libextra/net_tcp.rs b/src/libextra/net_tcp.rs index 9026dc25b2d..3ea085f5e86 100644 --- a/src/libextra/net_tcp.rs +++ b/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() { diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 36d91382fb2..406dfb086ea 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -514,7 +514,7 @@ pub fn filter_tests( fn filter_fn(test: TestDescAndFn, filter_str: &str) -> Option { - 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; } } diff --git a/src/libextra/uv_ll.rs b/src/libextra/uv_ll.rs index 17f1cd499b0..187960b9101 100644 --- a/src/libextra/uv_ll.rs +++ b/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) diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc index 95aea33d31a..416fabb6d8f 100644 --- a/src/libfuzzer/fuzzer.rc +++ b/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) { diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index d765bcff9e2..5af47880c30 100644 --- a/src/librustc/driver/driver.rs +++ b/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 { - 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 { - 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 } } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index dd70c2bfb56..0f3a6c7629f 100644 --- a/src/librustc/middle/resolve.rs +++ b/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::*`?)", diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 6b13c1fe1f6..976344a1825 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -607,13 +607,13 @@ mod test { #[test] fn write_markdown_should_write_mod_headers() { let markdown = render(~"mod moo { }"); - assert!(str::contains(markdown, "# Module `moo`")); + assert!(markdown.contains("# Module `moo`")); } #[test] fn should_leave_blank_line_after_header() { let markdown = render(~"mod morp { }"); - assert!(str::contains(markdown, "Module `morp`\n\n")); + assert!(markdown.contains("Module `morp`\n\n")); } #[test] @@ -669,10 +669,10 @@ mod test { let (page, markdown) = po.recv(); match page { doc::CratePage(_) => { - assert!(str::contains(markdown, "% Crate core")); + assert!(markdown.contains("% Crate core")); } doc::ItemPage(_) => { - assert!(str::contains(markdown, "% Module a")); + assert!(markdown.contains("% Module a")); } } } @@ -681,7 +681,7 @@ mod test { #[test] fn should_write_full_path_to_mod() { let markdown = render(~"mod a { mod b { mod c { } } }"); - assert!(str::contains(markdown, "# Module `a::b::c`")); + assert!(markdown.contains("# Module `a::b::c`")); } #[test] @@ -692,21 +692,20 @@ mod test { Body\"]\ mod a { }"); - assert!(str::contains(markdown, "#### Header\n\nBody\n\n")); + assert!(markdown.contains("#### Header\n\nBody\n\n")); } #[test] fn should_write_crate_description() { let markdown = render(~"#[doc = \"this is the crate\"];"); - assert!(str::contains(markdown, "this is the crate")); + assert!(markdown.contains("this is the crate")); } #[test] fn should_write_index() { let markdown = render(~"mod a { } mod b { }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n* [Module `a`](#module-a)\n\ * [Module `b`](#module-b)\n\n" )); @@ -715,20 +714,19 @@ mod test { #[test] fn should_write_index_brief() { let markdown = render(~"#[doc = \"test\"] mod a { }"); - assert!(str::contains(markdown, "(#module-a) - test\n")); + assert!(markdown.contains("(#module-a) - test\n")); } #[test] fn should_not_write_index_if_no_entries() { let markdown = render(~""); - assert!(!str::contains(markdown, "\n\n\n")); + assert!(!markdown.contains("\n\n\n")); } #[test] fn should_write_index_for_foreign_mods() { let markdown = render(~"extern { fn a(); }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n* [Function `a`](#function-a)\n\n" )); } @@ -737,32 +735,32 @@ mod test { fn should_write_foreign_fns() { let markdown = render( ~"extern { #[doc = \"test\"] fn a(); }"); - assert!(str::contains(markdown, "test")); + assert!(markdown.contains("test")); } #[test] fn should_write_foreign_fn_headers() { let markdown = render( ~"extern { #[doc = \"test\"] fn a(); }"); - assert!(str::contains(markdown, "## Function `a`")); + assert!(markdown.contains("## Function `a`")); } #[test] fn write_markdown_should_write_function_header() { let markdown = render(~"fn func() { }"); - assert!(str::contains(markdown, "## Function `func`")); + assert!(markdown.contains("## Function `func`")); } #[test] fn should_write_the_function_signature() { let markdown = render(~"#[doc = \"f\"] fn a() { }"); - assert!(str::contains(markdown, "\n fn a()\n")); + assert!(markdown.contains("\n fn a()\n")); } #[test] fn should_insert_blank_line_after_fn_signature() { let markdown = render(~"#[doc = \"f\"] fn a() { }"); - assert!(str::contains(markdown, "fn a()\n\n")); + assert!(markdown.contains("fn a()\n\n")); } #[test] @@ -783,19 +781,19 @@ mod test { ] }; let markdown = write_markdown_str(doc); - assert!(str::contains(markdown, " line 1\n line 2")); + assert!(markdown.contains(" line 1\n line 2")); } #[test] fn should_leave_blank_line_between_fn_header_and_sig() { let markdown = render(~"fn a() { }"); - assert!(str::contains(markdown, "Function `a`\n\n fn a()")); + assert!(markdown.contains("Function `a`\n\n fn a()")); } #[test] fn should_write_const_header() { let markdown = render(~"static a: bool = true;"); - assert!(str::contains(markdown, "## Const `a`\n\n")); + assert!(markdown.contains("## Const `a`\n\n")); } #[test] @@ -803,19 +801,19 @@ mod test { let markdown = render( ~"#[doc = \"b\"]\ static a: bool = true;"); - assert!(str::contains(markdown, "\n\nb\n\n")); + assert!(markdown.contains("\n\nb\n\n")); } #[test] fn should_write_enum_header() { let markdown = render(~"enum a { b }"); - assert!(str::contains(markdown, "## Enum `a`\n\n")); + assert!(markdown.contains("## Enum `a`\n\n")); } #[test] fn should_write_enum_description() { let markdown = render(~"#[doc = \"b\"] enum a { b }"); - assert!(str::contains(markdown, "\n\nb\n\n")); + assert!(markdown.contains("\n\nb\n\n")); } #[test] @@ -824,8 +822,7 @@ mod test { ~"enum a { \ #[doc = \"test\"] b, \ #[doc = \"test\"] c }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n#### Variants\n\ \n\ \n* `b` - test\ @@ -836,8 +833,7 @@ mod test { #[test] fn should_write_variant_list_without_descs() { let markdown = render(~"enum a { b, c }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n#### Variants\n\ \n\ \n* `b`\ @@ -849,8 +845,7 @@ mod test { fn should_write_variant_list_with_indent() { let markdown = render( ~"enum a { #[doc = \"line 1\\n\\nline 2\"] b, c }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n#### Variants\n\ \n\ \n* `b` - line 1\ @@ -863,8 +858,7 @@ mod test { #[test] fn should_write_variant_list_with_signatures() { let markdown = render(~"enum a { b(int), #[doc = \"a\"] c(int) }"); - assert!(str::contains( - markdown, + assert!(markdown.contains( "\n\n#### Variants\n\ \n\ \n* `b(int)`\ @@ -875,43 +869,43 @@ mod test { #[test] fn should_write_trait_header() { let markdown = render(~"trait i { fn a(); }"); - assert!(str::contains(markdown, "## Trait `i`")); + assert!(markdown.contains("## Trait `i`")); } #[test] fn should_write_trait_desc() { let markdown = render(~"#[doc = \"desc\"] trait i { fn a(); }"); - assert!(str::contains(markdown, "desc")); + assert!(markdown.contains("desc")); } #[test] fn should_write_trait_method_header() { let markdown = render(~"trait i { fn a(); }"); - assert!(str::contains(markdown, "### Method `a`")); + assert!(markdown.contains("### Method `a`")); } #[test] fn should_write_trait_method_signature() { let markdown = render(~"trait i { fn a(&self); }"); - assert!(str::contains(markdown, "\n fn a(&self)")); + assert!(markdown.contains("\n fn a(&self)")); } #[test] fn should_write_impl_header() { let markdown = render(~"impl int { fn a() { } }"); - assert!(str::contains(markdown, "## Implementation for `int`")); + assert!(markdown.contains("## Implementation for `int`")); } #[test] fn should_write_impl_header_with_bounds() { let markdown = render(~"impl int { }"); - assert!(str::contains(markdown, "## Implementation for `int` where ``")); + assert!(markdown.contains("## Implementation for `int` where ``")); } #[test] fn should_write_impl_header_with_trait() { let markdown = render(~"impl j for int { fn a() { } }"); - assert!(str::contains(markdown, + assert!(markdown.contains( "## Implementation of `j` for `int`")); } @@ -919,45 +913,45 @@ mod test { fn should_write_impl_desc() { let markdown = render( ~"#[doc = \"desc\"] impl int { fn a() { } }"); - assert!(str::contains(markdown, "desc")); + assert!(markdown.contains("desc")); } #[test] fn should_write_impl_method_header() { let markdown = render( ~"impl int { fn a() { } }"); - assert!(str::contains(markdown, "### Method `a`")); + assert!(markdown.contains("### Method `a`")); } #[test] fn should_write_impl_method_signature() { let markdown = render( ~"impl int { fn a(&mut self) { } }"); - assert!(str::contains(markdown, "\n fn a(&mut self)")); + assert!(markdown.contains("\n fn a(&mut self)")); } #[test] fn should_write_type_header() { let markdown = render(~"type t = int;"); - assert!(str::contains(markdown, "## Type `t`")); + assert!(markdown.contains("## Type `t`")); } #[test] fn should_write_type_desc() { let markdown = render( ~"#[doc = \"desc\"] type t = int;"); - assert!(str::contains(markdown, "\n\ndesc\n\n")); + assert!(markdown.contains("\n\ndesc\n\n")); } #[test] fn should_write_type_signature() { let markdown = render(~"type t = int;"); - assert!(str::contains(markdown, "\n\n type t = int\n\n")); + assert!(markdown.contains("\n\n type t = int\n\n")); } #[test] fn should_put_struct_header() { let markdown = render(~"struct S { field: () }"); - assert!(str::contains(markdown, "## Struct `S`\n\n")); + assert!(markdown.contains("## Struct `S`\n\n")); } } diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs index 61a8d11af7f..ddc1b7dfe21 100644 --- a/src/librustdoc/sectionalize_pass.rs +++ b/src/librustdoc/sectionalize_pass.rs @@ -191,9 +191,7 @@ mod test { Body\"]\ mod a { }"); - assert!(str::contains( - doc.cratemod().mods()[0].item.sections[0].header, - "Header")); + assert!(doc.cratemod().mods()[0].item.sections[0].header.contains("Header")); } #[test] @@ -204,9 +202,7 @@ mod test { Body\"]\ mod a { }"); - assert!(str::contains( - doc.cratemod().mods()[0].item.sections[0].body, - "Body")); + assert!(doc.cratemod().mods()[0].item.sections[0].body.contains("Body")); } #[test] @@ -229,12 +225,8 @@ mod test { Body\"]\ mod a { }"); - assert!(!str::contains( - doc.cratemod().mods()[0].desc().get(), - "Header")); - assert!(!str::contains( - doc.cratemod().mods()[0].desc().get(), - "Body")); + assert!(!doc.cratemod().mods()[0].desc().get().contains("Header")); + assert!(!doc.cratemod().mods()[0].desc().get().contains("Body")); } #[test] diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 98b210dd5a9..7ae59e524a0 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -1167,30 +1167,6 @@ fn match_at<'a,'b>(haystack: &'a str, needle: &'b str, at: uint) -> bool { } -/** - * Returns true if one string contains another - * - * # Arguments - * - * * haystack - The string to look in - * * needle - The string to look for - */ -pub fn contains<'a,'b>(haystack: &'a str, needle: &'b str) -> bool { - haystack.find_str(needle).is_some() -} - -/** - * Returns true if a string contains a char. - * - * # Arguments - * - * * haystack - The string to look in - * * needle - The char to look for - */ -pub fn contains_char(haystack: &str, needle: char) -> bool { - haystack.find(needle).is_some() -} - /** * Returns true if one string starts with another * @@ -2019,15 +1995,27 @@ pub trait StrSlice<'self> { /// Extension methods for strings impl<'self> StrSlice<'self> for &'self str { - /// Returns true if one string contains another + /** + * Returns true if one string contains another + * + * # Arguments + * + * * needle - The string to look for + */ #[inline] fn contains<'a>(&self, needle: &'a str) -> bool { - contains(*self, needle) + self.find_str(needle).is_some() } - /// Returns true if a string contains a char + /** + * Returns true if a string contains a char. + * + * # Arguments + * + * * needle - The char to look for + */ #[inline] fn contains_char(&self, needle: char) -> bool { - contains_char(*self, needle) + self.find(needle).is_some() } #[inline] @@ -3060,19 +3048,19 @@ mod tests { #[test] fn test_contains() { - assert!(contains("abcde", "bcd")); - assert!(contains("abcde", "abcd")); - assert!(contains("abcde", "bcde")); - assert!(contains("abcde", "")); - assert!(contains("", "")); - assert!(!contains("abcde", "def")); - assert!(!contains("", "a")); + assert!("abcde".contains("bcd")); + assert!("abcde".contains("abcd")); + assert!("abcde".contains("bcde")); + assert!("abcde".contains("")); + assert!("".contains("")); + assert!(!"abcde".contains("def")); + assert!(!"".contains("a")); let data = ~"ประเทศไทย中华Việt Nam"; - assert!(contains(data, "ประเ")); - assert!(contains(data, "ะเ")); - assert!(contains(data, "中华")); - assert!(!contains(data, "ไท华")); + assert!(data.contains("ประเ")); + assert!(data.contains("ะเ")); + assert!(data.contains("中华")); + assert!(!data.contains("ไท华")); } #[test]