rust-lang · bors · Jul 24, 2024 · Jul 8, 2024
diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
@@ -269,7 269,7 @@ impl str {
  without modifying the original"]
  #[stable(feature = "rust1", since = "1.0.0")]
  #[inline]
- pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {
  pub fn replace<P: Pattern>(&self, from: P, to: &str) -> String {
  let mut result = String::new();
  let mut last_end = 0;
  for (start, part) in self.match_indices(from) {
@@ -309,7 309,7 @@ impl str {
  #[must_use = "this returns the replaced string as a new allocation, \
  without modifying the original"]
  #[stable(feature = "str_replacen", since = "1.16.0")]
- pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String {
  pub fn replacen<P: Pattern>(&self, pat: P, to: &str, count: usize) -> String {
  // Hope to reduce the times of re-allocation
  let mut result = String::with_capacity(32);
  let mut last_end = 0;

diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
@@ -1497,10 1497,7 @@ impl String {
  /// ```
  #[cfg(not(no_global_oom_handling))]
  #[unstable(feature = "string_remove_matches", reason = "new API", issue = "72826")]
- pub fn remove_matches<'a, P>(&'a mut self, pat: P)
- where
- P: for<'x> Pattern<'x>,
- {
  pub fn remove_matches<P: Pattern>(&mut self, pat: P) {
  use core::str::pattern::Searcher;
 
  let rejections = {
@@ -2288,35 2285,41 @@ impl<'a> Extend<Cow<'a, str>> for String {
  reason = "API not fully fleshed out and ready to be stabilized",
  issue = "27721"
 )]
-impl<'a, 'b> Pattern<'a> for &'b String {
- type Searcher = <&'b str as Pattern<'a>>::Searcher;
 impl<'b> Pattern for &'b String {
  type Searcher<'a> = <&'b str as Pattern>::Searcher<'a>;
 
- fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {
  fn into_searcher(self, haystack: &str) -> <&'b str as Pattern>::Searcher<'_> {
  self[..].into_searcher(haystack)
  }
 
  #[inline]
- fn is_contained_in(self, haystack: &'a str) -> bool {
  fn is_contained_in(self, haystack: &str) -> bool {
  self[..].is_contained_in(haystack)
  }
 
  #[inline]
- fn is_prefix_of(self, haystack: &'a str) -> bool {
  fn is_prefix_of(self, haystack: &str) -> bool {
  self[..].is_prefix_of(haystack)
  }
 
  #[inline]
- fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> {
  fn strip_prefix_of(self, haystack: &str) -> Option<&str> {
  self[..].strip_prefix_of(haystack)
  }
 
  #[inline]
- fn is_suffix_of(self, haystack: &'a str) -> bool {
  fn is_suffix_of<'a>(self, haystack: &'a str) -> bool
  where
  Self::Searcher<'a>: core::str::pattern::ReverseSearcher<'a>,
  {
  self[..].is_suffix_of(haystack)
  }
 
  #[inline]
- fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> {
  fn strip_suffix_of<'a>(self, haystack: &'a str) -> Option<&str>
  where
  Self::Searcher<'a>: core::str::pattern::ReverseSearcher<'a>,
  {
  self[..].strip_suffix_of(haystack)
  }
 }

diff --git a/library/alloc/tests/str.rs b/library/alloc/tests/str.rs
@@ -1927,12 1927,10 @@ mod pattern {
  }
  }
 
- fn cmp_search_to_vec<'a>(
- rev: bool,
- pat: impl Pattern<'a, Searcher: ReverseSearcher<'a>>,
- haystack: &'a str,
- right: Vec<SearchStep>,
- ) {
  fn cmp_search_to_vec<P>(rev: bool, pat: P, haystack: &str, right: Vec<SearchStep>)
  where
  P: for<'a> Pattern<Searcher<'a>: ReverseSearcher<'a>>,
  {
  let mut searcher = pat.into_searcher(haystack);
  let mut v = vec![];
  loop {
@@ -2191,9 2189,9 @@ generate_iterator_test! {
 fn different_str_pattern_forwarding_lifetimes() {
  use std::str::pattern::Pattern;
 
- fn foo<'a, P>(p: P)
  fn foo<P>(p: P)
  where
- for<'b> &'b P: Pattern<'a>,
  for<'b> &'b P: Pattern,
  {
  for _ in 0..3 {
  "asdf".find(&p);