fixup! More generic impl of Replacer for closures

Use same lifetime for reference and type parameter of `Captures` (again)
because `Captures<'a>` is covariant over `'a`. This covers closures that
accept a `&'a Captures<'b>` as argument and have a result type that
depends either on `'b` or `'a`. Documentation was updated and
corresponding test cases have been added to `tests/misc.rs`.

A link to the blanket implementation has been added to the
"Implementation by closures" section of the documentation on `Replacer`.

Author: JanBeh

src/regex/string.rs

@@ -2378,14 +2378,14 @@ mod replacer_closure {
     /// [`Replacer`].
     pub trait ReplacerClosure<'a>
     where
-        Self: FnMut(&'a Captures<'_>) -> <Self as ReplacerClosure<'a>>::Output,
+        Self: FnMut(&'a Captures<'a>) -> <Self as ReplacerClosure<'a>>::Output,
     {
         /// Return type of the closure (may depend on lifetime `'a`).
         type Output: AsRef<str>;
     }
     impl<'a, F: ?Sized, O> ReplacerClosure<'a> for F
     where
-        F: FnMut(&'a Captures<'_>) -> O,
+        F: FnMut(&'a Captures<'a>) -> O,
         O: AsRef<str>,
     {
         type Output = O;
@@ -2429,8 +2429,10 @@ use replacer_closure::*;
 /// # Implementation by closures
 ///
 /// Closures that take an argument of type  `&'a Captures<'b>` for any `'a` and
-/// `'b: 'a` and which return a type `T: AsRef<str>` (that may depend on `'a`)
-/// implement the `Replacer` trait through a blanket implementation.
+/// `'b: 'a` and which return a type `T: AsRef<str>` (that may depend on `'a`
+/// or `'b`) implement the `Replacer` trait through a [blanket implementation].
+///
+/// [blanket implementation]: Self#impl-Replacer-for-F
 ///
 /// A simple example looks like this:
 ///
@@ -2578,7 +2580,7 @@ impl<'a> Replacer for &'a Cow<'a, str> {
 /// ```ignore
 /// impl<F, T> Replacer for F
 /// where
-///     F: for<'a> FnMut(&a Captures<'_>) -> T,
+///     F: for<'a> FnMut(&'a Captures<'a>) -> T,
 ///     T: AsRef<str>, // `T` may also depend on `'a`, which cannot be expressed easily
 /// {
 ///     /* … */

tests/misc.rs

@@ -141,3 +141,49 @@ fn dfa_handles_pathological_case() {
     };
     assert!(re.is_match(&text));
 }
+
+// Test if implementation of `Replacer` for closures covers any reasonable
+// lifetime combination in regard to the argument and return type.
+mod replacer_closure_lifetimes {
+    use regex::{Captures, Regex};
+    use std::borrow::Cow;
+    #[test]
+    fn reference_lifetime() {
+        fn coerce<F: for<'a> FnMut(&'a Captures<'_>) -> Cow<'a, str>>(
+            f: F,
+        ) -> F {
+            f
+        }
+        let s = Regex::new("x")
+            .unwrap()
+            .replace_all("x", coerce(|caps| Cow::Borrowed(&caps[0])));
+        assert_eq!(s, "x");
+    }
+    #[test]
+    fn parameter_lifetime() {
+        fn coerce<F: for<'b> FnMut(&Captures<'b>) -> Cow<'b, str>>(f: F) -> F {
+            f
+        }
+        let s = Regex::new("x").unwrap().replace_all(
+            "x",
+            coerce(|caps| Cow::Borrowed(caps.get(0).unwrap().as_str())),
+        );
+        assert_eq!(s, "x");
+    }
+    // Additionally demand that its sufficient if the closure accepts a single
+    // lifetime `'u` which is used both for the reference to and the lifetime
+    // argument of the `Captures` argument. Note that `Captures<'u>` is
+    // covariant over `'u`.
+    #[test]
+    fn unified_lifetime() {
+        fn coerce<F: for<'u> FnMut(&'u Captures<'u>) -> Cow<'u, str>>(
+            f: F,
+        ) -> F {
+            f
+        }
+        let s = Regex::new("x")
+            .unwrap()
+            .replace_all("x", coerce(|caps| Cow::Borrowed(&caps[0])));
+        assert_eq!(s, "x");
+    }
+}