feat: improve inherent associated type support

Extract the inherent impl type alias lookup into a shared
`find_inherent_assoc_type()` helper, wire it into IDE path
resolution

Author: EienMiku

crates/hir-ty/src/lower/path.rs

@@ -2,7 +2,7 @@
 
 use either::Either;
 use hir_def::{
-    AssocItemId, GenericDefId, GenericParamId, HasModule, Lookup, TraitId, TypeParamId,
+    GenericDefId, GenericParamId, Lookup, TraitId, TypeParamId,
     expr_store::{
         ExpressionStore, HygieneId,
         path::{
@@ -19,7 +19,6 @@ use hir_def::{
 };
 use rustc_type_ir::{
     AliasTerm, AliasTy, AliasTyKind,
-    fast_reject::{TreatParams, simplify_type},
     inherent::{GenericArgs as _, Region as _, Ty as _},
 };
 use smallvec::SmallVec;
@@ -35,7 +34,6 @@ use crate::{
         AssocTypeShorthandResolution, GenericPredicateSource, LifetimeElisionKind,
         PathDiagnosticCallbackData,
     },
-    method_resolution::InherentImpls,
     next_solver::{
         Binder, Clause, Const, DbInterner, EarlyBinder, ErrorGuaranteed, GenericArg, GenericArgs,
         Predicate, ProjectionPredicate, Region, TraitRef, Ty,
@@ -524,44 +522,9 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             }
             // associated types in inherent impl
             Some(TypeNs::AdtId(adt)) => {
-                let adt_ty = Ty::new_adt(
-                    interner,
-                    adt,
-                    GenericArgs::identity_for_item(interner, adt.into()),
-                );
-                let Some(simplified) = simplify_type(interner, adt_ty, TreatParams::AsRigid) else {
-                    return error_ty();
-                };
-
-                let module = adt.module(db);
-                let krate = module.krate(db);
-                let block = module.block(db);
-
-                let mut found_alias = None;
-                InherentImpls::for_each_crate_and_block(db, krate, block, &mut |impls| {
-                    if found_alias.is_some() {
-                        return;
-                    }
-                    for &impl_id in impls.for_self_ty(&simplified) {
-                        // skip trait impl, only need inherent impl
-                        if db.impl_signature(impl_id).target_trait.is_some() {
-                            continue;
-                        }
-                        for (name, item) in impl_id.impl_items(db).items.iter() {
-                            if name == assoc_name
-                                && let AssocItemId::TypeAliasId(alias_id) = item
-                            {
-                                found_alias = Some(*alias_id);
-                                break;
-                            }
-                        }
-                        if found_alias.is_some() {
-                            break;
-                        }
-                    }
-                });
-
-                let Some(alias_id) = found_alias else {
+                let Some(alias_id) =
+                    crate::method_resolution::find_inherent_assoc_type(db, adt, assoc_name)
+                else {
                     return error_ty();
                 };
 

crates/hir-ty/src/method_resolution.rs

@@ -13,8 +13,8 @@ use tracing::{debug, instrument};
 
 use base_db::Crate;
 use hir_def::{
-    AssocItemId, BlockId, BuiltinDeriveImplId, ConstId, FunctionId, GenericParamId, HasModule,
-    ImplId, ItemContainerId, ModuleId, TraitId,
+    AdtId, AssocItemId, BlockId, BuiltinDeriveImplId, ConstId, FunctionId, GenericParamId,
+    HasModule, ImplId, ItemContainerId, ModuleId, TraitId, TypeAliasId,
     attrs::AttrFlags,
     builtin_derive::BuiltinDeriveImplMethod,
     expr_store::path::GenericArgs as HirGenericArgs,
@@ -877,3 +877,42 @@ impl TraitImpls {
         }
     }
 }
+
+pub fn find_inherent_assoc_type(
+    db: &dyn HirDatabase,
+    adt: AdtId,
+    name: &Name,
+) -> Option<TypeAliasId> {
+    use rustc_type_ir::inherent::GenericArgs;
+
+    let interner = DbInterner::new_no_crate(db);
+
+    let adt_ty = Ty::new_adt(interner, adt, GenericArgs::identity_for_item(interner, adt.into()));
+    let simplified = simplify_type(interner, adt_ty, TreatParams::AsRigid)?;
+
+    let module = adt.module(db);
+    let mut found = None;
+
+    InherentImpls::for_each_crate_and_block(db, module.krate(db), module.block(db), &mut |impls| {
+        if found.is_some() {
+            return;
+        }
+        for &impl_id in impls.for_self_ty(&simplified) {
+            if db.impl_signature(impl_id).target_trait.is_some() {
+                continue;
+            }
+            for (n, item) in impl_id.impl_items(db).items.iter() {
+                if n == name
+                    && let AssocItemId::TypeAliasId(id) = item
+                {
+                    found = Some(*id);
+                    break;
+                }
+            }
+            if found.is_some() {
+                break;
+            }
+        }
+    });
+    found
+}

crates/hir/src/source_analyzer.rs

@@ -1678,6 +1678,14 @@ fn resolve_hir_path_(
             return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));
         }
 
+        // inherent associated types
+        if let (Some(unresolved), TypeNs::AdtId(adt_id)) = (&unresolved, &ty)
+            && let Some(alias_id) =
+                method_resolution::find_inherent_assoc_type(db, *adt_id, unresolved.name)
+        {
+            return Some(PathResolution::Def(ModuleDefId::from(alias_id).into()));
+        }
+
         let res = match ty {
             TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
             TypeNs::GenericParam(id) => PathResolution::TypeParam(id.into()),
@@ -1827,6 +1835,14 @@ fn resolve_hir_path_qualifier(
             return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));
         }
 
+        // inherent associated types
+        if let (Some(unresolved), TypeNs::AdtId(adt_id)) = (&unresolved, &ty)
+            && let Some(alias_id) =
+                method_resolution::find_inherent_assoc_type(db, *adt_id, unresolved.name)
+        {
+            return Some(PathResolution::Def(ModuleDefId::from(alias_id).into()));
+        }
+
         let res = match ty {
             TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
             TypeNs::GenericParam(id) => PathResolution::TypeParam(id.into()),

crates/ide/src/goto_definition.rs

@@ -1811,6 +1811,40 @@ fn f() -> impl Iterator<Item$0 = u8> {}
         );
     }
 
+    #[test]
+    fn goto_def_for_inherent_assoc_ty_in_path() {
+        check(
+            r#"
+struct A;
+impl A {
+    type B = i32;
+       //^
+}
+
+fn main() {
+    let _x: A::B$0;
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_inherent_assoc_ty_in_qualifier() {
+        check(
+            r#"
+struct A;
+impl A {
+    type B = [u8; 3];
+       //^
+}
+
+fn main() {
+    let _x = A::B$0::default();
+}
+"#,
+        );
+    }
+
     #[test]
     fn goto_def_for_super_assoc_ty_in_path() {
         check(