Auto merge of #12509 - Veykril:ty-utils, r=Veykril

internal: Remove `Generics::type_iter` in favor of `Generics::iter`

crates/hir-def/src/generics.rs

@@ -133,14 +133,6 @@ pub enum WherePredicateTypeTarget {
 }
 
 impl GenericParams {
-    // FIXME: almost every usecase of this function is wrong. every one should check
-    // const generics
-    pub fn type_iter<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = (Idx<TypeOrConstParamData>, &TypeParamData)> {
-        self.type_or_consts.iter().filter_map(|x| x.1.type_param().map(|y| (x.0, y)))
-    }
-
     /// Iterator of type_or_consts field
     pub fn iter<'a>(
         &'a self,

crates/hir-ty/src/lower.rs

@@ -292,9 +292,13 @@ pub fn lower_ty_ext(&self, type_ref: &TypeRef) -> (Ty, Option<TypeNs>) {
                         if let Some(def) = self.resolver.generic_def() {
                             let generics = generics(self.db.upcast(), def);
                             let param = generics
-                                .type_iter()
+                                .iter()
                                 .filter(|(_, data)| {
-                                    data.provenance == TypeParamProvenance::ArgumentImplTrait
+                                    matches!(
+                                        data,
+                                        TypeOrConstParamData::TypeParamData(data)
+                                        if data.provenance == TypeParamProvenance::ArgumentImplTrait
+                                    )
                                 })
                                 .nth(idx as usize)
                                 .map_or(TyKind::Error, |(id, _)| {

crates/hir-ty/src/utils.rs

@@ -8,7 +8,7 @@
 use hir_def::{
     db::DefDatabase,
     generics::{
-        GenericParams, TypeOrConstParamData, TypeParamData, TypeParamProvenance, WherePredicate,
+        GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate,
         WherePredicateTypeTarget,
     },
     intern::Interned,
@@ -204,25 +204,6 @@ pub(crate) struct Generics {
 }
 
 impl Generics {
-    // FIXME: we should drop this and handle const and type generics at the same time
-    pub(crate) fn type_iter<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = (TypeOrConstParamId, &'a TypeParamData)> + 'a {
-        self.parent_generics
-            .as_ref()
-            .into_iter()
-            .flat_map(|it| {
-                it.params
-                    .type_iter()
-                    .map(move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p))
-            })
-            .chain(
-                self.params.type_iter().map(move |(local_id, p)| {
-                    (TypeOrConstParamId { parent: self.def, local_id }, p)
-                }),
-            )
-    }
-
     pub(crate) fn iter_id<'a>(
         &'a self,
     ) -> impl Iterator<Item = Either<TypeParamId, ConstParamId>> + 'a {