Ignore associated types in traits when considering type complexity

clippy_lints/src/types/mod.rs

@@ -350,16 +350,18 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         match item.kind {
-            ImplItemKind::Const(ty, _) | ImplItemKind::TyAlias(ty) => self.check_ty(
+            ImplItemKind::Const(ty, _) => self.check_ty(
                 cx,
                 ty,
                 CheckTyContext {
                     is_in_trait_impl: true,
                     ..CheckTyContext::default()
                 },
             ),
-            // methods are covered by check_fn
-            ImplItemKind::Fn(..) => (),
+            // Methods are covered by check_fn.
+            // Type aliases are ignored because oftentimes it's impossible to
+            // make type alias declaration in trait simpler, see #1013
+            ImplItemKind::Fn(..) | ImplItemKind::TyAlias(..) => (),
         }
     }
 

tests/ui/type_complexity_issue_1013.rs

@@ -0,0 +1,23 @@
+#![warn(clippy::type_complexity)]
+use std::iter::{Filter, Map};
+use std::vec::IntoIter;
+
+struct S;
+
+impl IntoIterator for S {
+    type Item = i32;
+    // Should not warn since there is no way to simplify this
+    type IntoIter = Filter<Map<IntoIter<i32>, fn(i32) -> i32>, fn(&i32) -> bool>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        fn m(a: i32) -> i32 {
+            a
+        }
+        fn p(_: &i32) -> bool {
+            true
+        }
+        vec![1i32, 2, 3].into_iter().map(m as fn(_) -> _).filter(p)
+    }
+}
+
+fn main() {}