Update from dev branch with recently merged master:

- follow master on changed capturing args from TyKind::ImplTrait() to GenericBound::Use(),
  capturing args are unused here.
- some renames, a.o. to follow api guidelines.
- added/improved code docs, a.o. mention trait implementation declaration.
- remove some unused code,
- derive PartialEq and friends,
- use Spans.to().

Author: Ype Kingma

CHANGELOG.md

@@ -5357,6 +5357,7 @@ Released 2018-09-13
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
 [`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop
 [`explicit_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop
+[`explicit_lifetimes_bound_nested_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_lifetimes_bound_nested_ref
 [`explicit_write`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write
 [`extend_from_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_from_slice
 [`extend_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_with_drain
@@ -5418,6 +5419,7 @@ Released 2018-09-13
 [`impl_trait_in_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_in_params
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
+[`implicit_lifetimes_bound_nested_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_lifetimes_bound_nested_ref
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub

clippy_lints/src/declared_lints.rs

@@ -267,6 +267,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::let_with_type_underscore::LET_WITH_TYPE_UNDERSCORE_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
     crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
+    crate::lifetimes_bound_nested_ref::IMPLICIT_LIFETIMES_BOUND_INFO,
+    crate::lifetimes_bound_nested_ref::EXPLICIT_LIFETIMES_BOUND_INFO,
     crate::lines_filter_map_ok::LINES_FILTER_MAP_OK_INFO,
     crate::literal_representation::DECIMAL_LITERAL_REPRESENTATION_INFO,
     crate::literal_representation::INCONSISTENT_DIGIT_GROUPING_INFO,

clippy_lints/src/lib.rs

@@ -196,6 +196,7 @@ mod let_if_seq;
 mod let_underscore;
 mod let_with_type_underscore;
 mod lifetimes;
+mod lifetimes_bound_nested_ref;
 mod lines_filter_map_ok;
 mod literal_representation;
 mod loops;
@@ -1164,6 +1165,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(assigning_clones::AssigningClones::new(msrv())));
     store.register_late_pass(|_| Box::new(zero_repeat_side_effects::ZeroRepeatSideEffects));
     store.register_late_pass(|_| Box::new(manual_unwrap_or_default::ManualUnwrapOrDefault));
+    store.register_early_pass(|| Box::new(lifetimes_bound_nested_ref::LifetimesBoundNestedRef));
     store.register_late_pass(|_| Box::new(integer_division_remainder_used::IntegerDivisionRemainderUsed));
     store.register_late_pass(move |_| {
         Box::new(macro_metavars_in_unsafe::ExprMetavarsInUnsafe {

clippy_lints/src/lifetimes_bound_nested_ref.rs

@@ -0,0 +1,69 @@
+#![warn(clippy::explicit_lifetimes_bound)]
+use core::mem::MaybeUninit;
+
+// issue 25860, missing implicit bound
+pub fn lifetime_translator_1<'lfta, 'lftb: 'lfta, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+    val_a
+}
+
+// helper declarations for issue 84591
+trait Supertrait<'a, 'b> {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T;
+}
+
+struct MyStruct;
+
+impl<'a: 'b, 'b> Supertrait<'a, 'b> for MyStruct {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T {
+        x
+    }
+}
+
+trait Subtrait<'a, 'b, R>: Supertrait<'a, 'b> {}
+
+// issue 84591, missing implicit bound:
+impl<'a: 'b, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+
+// helper declarations for issue 100051
+trait Trait1 {
+    type Type1;
+}
+
+impl<T1> Trait1 for T1 {
+    type Type1 = ();
+}
+
+trait Extend1<'a, 'b> {
+    fn extend(self, s: &'a str) -> &'b str;
+}
+
+// issue 100051, missing implicit bound
+impl<'a: 'b, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+    fn extend(self, s: &'a str) -> &'b str {
+        s
+    }
+}
+
+// from the httparse crate, lib.rs: bounds implied by argument and return types are the same
+// missing implicit bound:
+unsafe fn deinit_slice_mut<'a, 'b: 'a, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+    let s: *mut &mut [T] = s;
+    let s = s as *mut &mut [MaybeUninit<T>];
+    &mut *s
+}
+
+// test case for unnamed references.
+// helper declarations:
+struct Thing1<'a> {
+    ref_u8: &'a u8,
+}
+struct Thing2<'a> {
+    ref_u16: &'a u16,
+}
+// missing implicit bound
+fn test_unnamed_ref<'a: 'b, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+    let _ = w2;
+    w1.ref_u8
+}
+
+fn main() {}

tests/ui/lifetimes_bound_nested_ref_expl.fixed

@@ -0,0 +1,69 @@
+#![warn(clippy::explicit_lifetimes_bound)]
+use core::mem::MaybeUninit;
+
+// issue 25860, missing implicit bound
+pub fn lifetime_translator_1<'lfta, 'lftb, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+    val_a
+}
+
+// helper declarations for issue 84591
+trait Supertrait<'a, 'b> {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T;
+}
+
+struct MyStruct;
+
+impl<'a: 'b, 'b> Supertrait<'a, 'b> for MyStruct {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T {
+        x
+    }
+}
+
+trait Subtrait<'a, 'b, R>: Supertrait<'a, 'b> {}
+
+// issue 84591, missing implicit bound:
+impl<'a, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+
+// helper declarations for issue 100051
+trait Trait1 {
+    type Type1;
+}
+
+impl<T1> Trait1 for T1 {
+    type Type1 = ();
+}
+
+trait Extend1<'a, 'b> {
+    fn extend(self, s: &'a str) -> &'b str;
+}
+
+// issue 100051, missing implicit bound
+impl<'a, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+    fn extend(self, s: &'a str) -> &'b str {
+        s
+    }
+}
+
+// from the httparse crate, lib.rs: bounds implied by argument and return types are the same
+// missing implicit bound:
+unsafe fn deinit_slice_mut<'a, 'b, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+    let s: *mut &mut [T] = s;
+    let s = s as *mut &mut [MaybeUninit<T>];
+    &mut *s
+}
+
+// test case for unnamed references.
+// helper declarations:
+struct Thing1<'a> {
+    ref_u8: &'a u8,
+}
+struct Thing2<'a> {
+    ref_u16: &'a u16,
+}
+// missing implicit bound
+fn test_unnamed_ref<'a, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+    let _ = w2;
+    w1.ref_u8
+}
+
+fn main() {}

tests/ui/lifetimes_bound_nested_ref_expl.rs

@@ -0,0 +1,64 @@
+error: missing lifetimes bound declaration: 'lftb: 'lfta
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:5:37
+   |
+LL | pub fn lifetime_translator_1<'lfta, 'lftb, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+   |                                     ^^^^^ help: try: `'lftb: 'lfta`
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:5:55
+   |
+LL | pub fn lifetime_translator_1<'lfta, 'lftb, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+   |                                                       ^^^^^^^^^^^^
+   = note: `-D clippy::explicit-lifetimes-bound` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::explicit_lifetimes_bound)]`
+
+error: missing lifetimes bound declaration: 'a: 'b
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:25:6
+   |
+LL | impl<'a, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+   |      ^^ help: try: `'a: 'b`
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:25:32
+   |
+LL | impl<'a, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+   |                                ^^^^^^
+
+error: missing lifetimes bound declaration: 'a: 'b
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:41:6
+   |
+LL | impl<'a, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+   |      ^^ help: try: `'a: 'b`
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:41:36
+   |
+LL | impl<'a, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+   |                                    ^^^^^^
+
+error: missing lifetimes bound declaration: 'b: 'a
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:49:32
+   |
+LL | unsafe fn deinit_slice_mut<'a, 'b, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+   |                                ^^ help: try: `'b: 'a`
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:49:43
+   |
+LL | unsafe fn deinit_slice_mut<'a, 'b, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+   |                                           ^^^^^^^^^^
+
+error: missing lifetimes bound declaration: 'a: 'b
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:64:21
+   |
+LL | fn test_unnamed_ref<'a, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+   |                     ^^ help: try: `'a: 'b`
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_expl.rs:64:34
+   |
+LL | fn test_unnamed_ref<'a, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+

tests/ui/lifetimes_bound_nested_ref_expl.stderr

@@ -0,0 +1,71 @@
+// This was started as a copy from the fixed output of lifetimes_bound_nested_ref_expl.fixed 
+// Adapted: the lint name and the code comments.
+#![warn(clippy::implicit_lifetimes_bound)]
+use core::mem::MaybeUninit;
+
+// issue 25860, with declared bound
+pub fn lifetime_translator_1<'lfta, 'lftb: 'lfta, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+    val_a
+}
+
+// helper declarations for issue 84591
+trait Supertrait<'a, 'b> {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T;
+}
+
+struct MyStruct;
+
+impl<'a: 'b, 'b> Supertrait<'a, 'b> for MyStruct {
+    fn convert<T: ?Sized>(x: &'a T) -> &'b T {
+        x
+    }
+}
+
+trait Subtrait<'a, 'b, R>: Supertrait<'a, 'b> {}
+
+// issue 84591, with declared bound:
+impl<'a: 'b, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+
+// helper declarations for issue 100051
+trait Trait1 {
+    type Type1;
+}
+
+impl<T1> Trait1 for T1 {
+    type Type1 = ();
+}
+
+trait Extend1<'a, 'b> {
+    fn extend(self, s: &'a str) -> &'b str;
+}
+
+// issue 100051, with declared bound
+impl<'a: 'b, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+    fn extend(self, s: &'a str) -> &'b str {
+        s
+    }
+}
+
+// from the httparse crate, lib.rs: bounds implied by argument and return types are the same
+// with declared bound:
+unsafe fn deinit_slice_mut<'a, 'b: 'a, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+    let s: *mut &mut [T] = s;
+    let s = s as *mut &mut [MaybeUninit<T>];
+    &mut *s
+}
+
+// test case for unnamed references.
+// helper declarations:
+struct Thing1<'a> {
+    ref_u8: &'a u8,
+}
+struct Thing2<'a> {
+    ref_u16: &'a u16,
+}
+// with declared bound
+fn test_unnamed_ref<'a: 'b, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+    let _ = w2;
+    w1.ref_u8
+}
+
+fn main() {}

tests/ui/lifetimes_bound_nested_ref_impl.rs

@@ -0,0 +1,64 @@
+error: declared lifetimes bound: 'lftb: 'lfta is redundant, but do not remove it
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:7:42
+   |
+LL | pub fn lifetime_translator_1<'lfta, 'lftb: 'lfta, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+   |                                          ^^^^^^^
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:7:62
+   |
+LL | pub fn lifetime_translator_1<'lfta, 'lftb: 'lfta, T>(val_a: &'lfta &'lftb T, _val_b: &'lftb T) -> &'lfta T {
+   |                                                              ^^^^^^^^^^^^
+   = note: `-D clippy::implicit-lifetimes-bound` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::implicit_lifetimes_bound)]`
+
+error: declared lifetimes bound: 'a: 'b is redundant, but do not remove it
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:27:8
+   |
+LL | impl<'a: 'b, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+   |        ^^^^
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:27:36
+   |
+LL | impl<'a: 'b, 'b> Subtrait<'a, 'b, &'b &'a ()> for MyStruct {}
+   |                                    ^^^^^^
+
+error: declared lifetimes bound: 'a: 'b is redundant, but do not remove it
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:43:8
+   |
+LL | impl<'a: 'b, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+   |        ^^^^
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:43:40
+   |
+LL | impl<'a: 'b, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+   |                                        ^^^^^^
+
+error: declared lifetimes bound: 'b: 'a is redundant, but do not remove it
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:51:34
+   |
+LL | unsafe fn deinit_slice_mut<'a, 'b: 'a, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+   |                                  ^^^^
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:51:47
+   |
+LL | unsafe fn deinit_slice_mut<'a, 'b: 'a, T>(s: &'a mut &'b mut [T]) -> &'a mut &'b mut [MaybeUninit<T>] {
+   |                                               ^^^^^^^^^^
+
+error: declared lifetimes bound: 'a: 'b is redundant, but do not remove it
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:66:23
+   |
+LL | fn test_unnamed_ref<'a: 'b, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+   |                       ^^^^
+   |
+note: this lifetimes bound is implied here:
+  --> tests/ui/lifetimes_bound_nested_ref_impl.rs:66:38
+   |
+LL | fn test_unnamed_ref<'a: 'b, 'b>(w1: &'b mut &mut Thing1<'a>, w2: &mut Thing2<'b>) -> &'a u8 {
+   |                                      ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+