Auto merge of #13725 - bvanjoi:resolve-const-triat-impls, r=flodiebold

feat: resolve const for trait impls

Fixed #13694

crates/hir-ty/src/consteval.rs

@@ -351,6 +351,7 @@ pub fn eval_const(
                         .infer
                         .assoc_resolutions_for_expr(expr_id)
                         .ok_or(ConstEvalError::SemanticError("unresolved assoc item"))?
+                        .0
                     {
                         hir_def::AssocItemId::FunctionId(_) => {
                             Err(ConstEvalError::NotSupported("assoc function"))

crates/hir-ty/src/infer.rs

@@ -349,7 +349,7 @@ pub struct InferenceResult {
     /// For each struct literal or pattern, records the variant it resolves to.
     variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
     /// For each associated item record what it resolves to
-    assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>,
+    assoc_resolutions: FxHashMap<ExprOrPatId, (AssocItemId, Option<Substitution>)>,
     pub diagnostics: Vec<InferenceDiagnostic>,
     pub type_of_expr: ArenaMap<ExprId, Ty>,
     /// For each pattern record the type it resolves to.
@@ -379,11 +379,17 @@ impl InferenceResult {
     pub fn variant_resolution_for_pat(&self, id: PatId) -> Option<VariantId> {
         self.variant_resolutions.get(&id.into()).copied()
     }
-    pub fn assoc_resolutions_for_expr(&self, id: ExprId) -> Option<AssocItemId> {
-        self.assoc_resolutions.get(&id.into()).copied()
+    pub fn assoc_resolutions_for_expr(
+        &self,
+        id: ExprId,
+    ) -> Option<(AssocItemId, Option<Substitution>)> {
+        self.assoc_resolutions.get(&id.into()).cloned()
     }
-    pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<AssocItemId> {
-        self.assoc_resolutions.get(&id.into()).copied()
+    pub fn assoc_resolutions_for_pat(
+        &self,
+        id: PatId,
+    ) -> Option<(AssocItemId, Option<Substitution>)> {
+        self.assoc_resolutions.get(&id.into()).cloned()
     }
     pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch> {
         self.type_mismatches.get(&expr.into())
@@ -647,8 +653,13 @@ impl<'a> InferenceContext<'a> {
         self.result.variant_resolutions.insert(id, variant);
     }
 
-    fn write_assoc_resolution(&mut self, id: ExprOrPatId, item: AssocItemId) {
-        self.result.assoc_resolutions.insert(id, item);
+    fn write_assoc_resolution(
+        &mut self,
+        id: ExprOrPatId,
+        item: AssocItemId,
+        subs: Option<Substitution>,
+    ) {
+        self.result.assoc_resolutions.insert(id, (item, subs));
     }
 
     fn write_pat_ty(&mut self, pat: PatId, ty: Ty) {

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

@@ -212,7 +212,7 @@ impl<'a> InferenceContext<'a> {
             AssocItemId::TypeAliasId(_) => unreachable!(),
         };
 
-        self.write_assoc_resolution(id, item);
+        self.write_assoc_resolution(id, item, Some(trait_ref.substitution.clone()));
         Some((def, Some(trait_ref.substitution)))
     }
 
@@ -273,7 +273,7 @@ impl<'a> InferenceContext<'a> {
                     ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,
                 };
 
-                self.write_assoc_resolution(id, item);
+                self.write_assoc_resolution(id, item, substs.clone());
                 Some((def, substs))
             },
         )

crates/hir-ty/src/method_resolution.rs

@@ -642,6 +642,30 @@ pub(crate) fn iterate_method_candidates<T>(
     slot
 }
 
+pub fn lookup_impl_const(
+    db: &dyn HirDatabase,
+    env: Arc<TraitEnvironment>,
+    const_id: ConstId,
+    subs: Substitution,
+) -> ConstId {
+    let trait_id = match const_id.lookup(db.upcast()).container {
+        ItemContainerId::TraitId(id) => id,
+        _ => return const_id,
+    };
+    let substitution = Substitution::from_iter(Interner, subs.iter(Interner));
+    let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution };
+
+    let const_data = db.const_data(const_id);
+    let name = match const_data.name.as_ref() {
+        Some(name) => name,
+        None => return const_id,
+    };
+
+    lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name)
+        .and_then(|assoc| if let AssocItemId::ConstId(id) = assoc { Some(id) } else { None })
+        .unwrap_or(const_id)
+}
+
 /// Looks up the impl method that actually runs for the trait method `func`.
 ///
 /// Returns `func` if it's not a method defined in a trait or the lookup failed.
@@ -663,15 +687,17 @@ pub fn lookup_impl_method(
     };
 
     let name = &db.function_data(func).name;
-    lookup_impl_method_for_trait_ref(trait_ref, db, env, name).unwrap_or(func)
+    lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name)
+        .and_then(|assoc| if let AssocItemId::FunctionId(id) = assoc { Some(id) } else { None })
+        .unwrap_or(func)
 }
 
-fn lookup_impl_method_for_trait_ref(
+fn lookup_impl_assoc_item_for_trait_ref(
     trait_ref: TraitRef,
     db: &dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     name: &Name,
-) -> Option<FunctionId> {
+) -> Option<AssocItemId> {
     let self_ty = trait_ref.self_type_parameter(Interner);
     let self_ty_fp = TyFingerprint::for_trait_impl(&self_ty)?;
     let impls = db.trait_impls_in_deps(env.krate);
@@ -681,7 +707,15 @@ fn lookup_impl_method_for_trait_ref(
 
     let impl_data = find_matching_impl(impls, table, trait_ref)?;
     impl_data.items.iter().find_map(|it| match it {
-        AssocItemId::FunctionId(f) => (db.function_data(*f).name == *name).then(|| *f),
+        AssocItemId::FunctionId(f) => {
+            (db.function_data(*f).name == *name).then(|| AssocItemId::FunctionId(*f))
+        }
+        AssocItemId::ConstId(c) => db
+            .const_data(*c)
+            .name
+            .as_ref()
+            .map(|n| *n == *name)
+            .and_then(|result| if result { Some(AssocItemId::ConstId(*c)) } else { None }),
         _ => None,
     })
 }