Squashed commit for issue 100051

Author: Ype Kingma

clippy_lints/src/lifetimes_bound_nested_ref.rs

@@ -26,14 +26,20 @@ use std::collections::BTreeSet;
 
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{GenericArg, GenericBound, Generics, Item, ItemKind, WherePredicate};
+use rustc_hir::{
+    GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, Item, ItemKind, LifetimeParamKind,
+    WherePredicate,
+};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::ty_kind::TyKind;
 use rustc_middle::ty::{BoundRegionKind, RegionKind, Ty};
 use rustc_session::impl_lint_pass;
 use rustc_span::Symbol;
 
+extern crate rustc_type_ir;
+use rustc_type_ir::AliasKind;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks function arguments and return values that have a nested reference type with lifetimes,
@@ -119,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for LifetimesBoundNestedRef {
         let FnKind::ItemFn(_ident, generics, _fn_header) = fn_kind else {
             return;
         };
-        if generics.params.is_empty() {
+        if !at_least_2_explicit_lifetimes(generics.params) {
             return;
         }
         let declared_bounds = get_declared_bounds(generics);
@@ -140,12 +146,12 @@ impl<'tcx> LateLintPass<'tcx> for LifetimesBoundNestedRef {
         let ItemKind::Impl(impl_item) = item.kind else {
             return;
         };
-        if impl_item.generics.params.is_empty() {
-            return;
-        }
         let Some(of_trait_ref) = impl_item.of_trait else {
             return;
         };
+        if !at_least_2_explicit_lifetimes(impl_item.generics.params) {
+            return;
+        }
         let declared_bounds = get_declared_bounds(impl_item.generics);
         let mut implied_bounds = BTreeSet::new();
         for path_segment in of_trait_ref.path.segments {
@@ -159,6 +165,8 @@ impl<'tcx> LateLintPass<'tcx> for LifetimesBoundNestedRef {
                 }
             }
         }
+        let for_clause_ty = hir_ty_to_ty(cx.tcx, impl_item.self_ty); // impl ... for   for_clause_type   {}
+        collect_nested_ref_implied_bounds(for_clause_ty, None, &mut implied_bounds);
         report_lints(cx, impl_item.generics.span, &declared_bounds, &implied_bounds);
     }
 }
@@ -206,6 +214,19 @@ impl Ord for BoundLftPair {
     }
 }
 
+fn at_least_2_explicit_lifetimes<'a>(generic_params: &'a [GenericParam<'a>]) -> bool {
+    generic_params
+        .iter()
+        .filter(|gp| match gp.kind {
+            GenericParamKind::Lifetime {
+                kind: LifetimeParamKind::Explicit,
+            } => true,
+            _ => false,
+        })
+        .enumerate()
+        .any(|(i, _)| i >= 1)
+}
+
 fn get_declared_bounds(generics: &Generics<'_>) -> BTreeSet<BoundLftPair> {
     let mut declared_bounds = BTreeSet::new();
     for where_predicate in generics.predicates {
@@ -269,6 +290,15 @@ fn collect_nested_ref_implied_bounds(
         TyKind::Slice(element_ty) => {
             collect_nested_ref_implied_bounds(element_ty, outlived_lft_sym_opt, implied_bounds);
         },
+        TyKind::Alias(AliasKind::Projection, alias_ty) => {
+            // a for clause in: impl ... for ... {}
+            for alias_generic_arg in alias_ty.args {
+                let Some(alias_ty) = alias_generic_arg.as_type() else {
+                    continue;
+                };
+                collect_nested_ref_implied_bounds(alias_ty, outlived_lft_sym_opt, implied_bounds);
+            }
+        },
         _ => {},
     }
 }

tests/ui/lifetimes_bound_nested_ref.rs

@@ -35,6 +35,45 @@ trait Subtrait2<'a, 'b, R>: Supertrait<'a, 'b> {}
 // issue 84591, with bound:
 impl<'a: 'b, 'b> Subtrait2<'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, without explicit lifetimes bound
+impl<'a, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+    fn extend(self, s: &'a str) -> &'b str {
+        s
+    }
+}
+
+trait Trait2 {
+    type Type2;
+}
+
+impl<T2> Trait2 for T2 {
+    type Type2 = ();
+}
+
+trait Extend2<'a, 'b> {
+    fn extend(self, s: &'a str) -> &'b str;
+}
+
+// issue 100051, with explicit lifetimes bound
+impl<'a: 'b, 'b> Extend2<'a, 'b> for <&'b &'a () as Trait2>::Type2 {
+    fn extend(self, s: &'a str) -> &'b str {
+        s
+    }
+}
+
 fn main() {
     // test code goes here
 }

tests/ui/lifetimes_bound_nested_ref.stderr

@@ -28,5 +28,17 @@ error: declared lifetime bound is implied: 'a: 'b
 LL | impl<'a: 'b, 'b> Subtrait2<'a, 'b, &'b &'a ()> for MyStruct {}
    |     ^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: missing lifetime bound declation: 'a: 'b
+  --> tests/ui/lifetimes_bound_nested_ref.rs:52:5
+   |
+LL | impl<'a, 'b> Extend1<'a, 'b> for <&'b &'a () as Trait1>::Type1 {
+   |     ^^^^^^^^
+
+error: declared lifetime bound is implied: 'a: 'b
+  --> tests/ui/lifetimes_bound_nested_ref.rs:71:5
+   |
+LL | impl<'a: 'b, 'b> Extend2<'a, 'b> for <&'b &'a () as Trait2>::Type2 {
+   |     ^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors