feat: support inherent associated type paths

Add support for resolving paths for inherent associated types

Author: EienMiku

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

@@ -2,7 +2,7 @@
 
 use either::Either;
 use hir_def::{
-    GenericDefId, GenericParamId, Lookup, TraitId, TypeParamId,
+    AssocItemId, GenericDefId, GenericParamId, HasModule, Lookup, TraitId, TypeParamId,
     expr_store::{
         ExpressionStore, HygieneId,
         path::{
@@ -19,6 +19,7 @@ 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;
@@ -34,6 +35,7 @@ use crate::{
         AssocTypeShorthandResolution, GenericPredicateSource, LifetimeElisionKind,
         PathDiagnosticCallbackData,
     },
+    method_resolution::InherentImpls,
     next_solver::{
         Binder, Clause, Const, DbInterner, EarlyBinder, ErrorGuaranteed, GenericArg, GenericArgs,
         Predicate, ProjectionPredicate, Region, TraitRef, Ty,
@@ -520,6 +522,51 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                     .skip_binder();
                 (assoc_type, EarlyBinder::bind(trait_args).instantiate(interner, impl_trait.args))
             }
+            // 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 {
+                    return error_ty();
+                };
+
+                return self.lower_path_inner(TyDefId::TypeAliasId(alias_id), infer_args);
+            }
             _ => return error_ty(),
         };
 

crates/hir-ty/src/tests/traits.rs

@@ -5142,3 +5142,34 @@ fn foo(v: Struct<f32>) {
     "#,
     );
 }
+
+#[test]
+fn inherent_associated_type_path() {
+    check_infer(
+        r#"
+#![feature(inherent_associated_types)]
+
+struct A;
+impl A {
+    type B = i32;
+}
+
+trait C { fn foo() -> Self; }
+impl C for A::B {
+    fn foo() -> Self { 1 }
+}
+
+fn main() {
+    let x: A::B = C::foo();
+}
+"#,
+        expect![[r#"
+            149..154 '{ 1 }': i32
+            151..152 '1': i32
+            168..199 '{     ...o(); }': ()
+            178..179 'x': i32
+            188..194 'C::foo': fn foo<i32>() -> i32
+            188..196 'C::foo()': i32
+        "#]],
+    );
+}