Use ImplKey in abilities store public API

crates/compiler/solve/src/ability.rs

@@ -394,7 +394,10 @@ impl ObligationCache<'_> {
         for &member in members_of_ability {
             if self
                 .abilities_store
-                .get_implementation(member, opaque)
+                .get_implementation(roc_can::abilities::ImplKey {
+                    opaque,
+                    ability_member: ability,
+                })
                 .is_none()
             {
                 let root_data = self.abilities_store.member_def(member).unwrap();
@@ -671,7 +674,12 @@ pub fn resolve_ability_specialization(
 
     let resolved = match obligated {
         Obligated::Opaque(symbol) => {
-            match abilities_store.get_implementation(ability_member, symbol)? {
+            let impl_key = roc_can::abilities::ImplKey {
+                opaque: symbol,
+                ability_member,
+            };
+
+            match abilities_store.get_implementation(impl_key)? {
                 roc_types::types::MemberImpl::Impl(spec_symbol) => {
                     Resolved::Specialization(*spec_symbol)
                 }

crates/compiler/solve/src/module.rs

@@ -1,5 +1,5 @@
 use crate::solve::{self, Aliases};
-use roc_can::abilities::{AbilitiesStore, ImplKey, ResolvedImpl};
+use roc_can::abilities::{AbilitiesStore, ResolvedImpl};
 use roc_can::constraint::{Constraint as ConstraintSoa, Constraints};
 use roc_can::expr::PendingDerives;
 use roc_can::module::{ExposedByModule, ResolvedImplementations, RigidVariables};
@@ -190,16 +190,14 @@ pub fn extract_module_owned_implementations(
 ) -> ResolvedImplementations {
     abilities_store
         .iter_declared_implementations()
-        .filter_map(|((member, typ), member_impl)| {
+        .filter_map(|(impl_key, member_impl)| {
             // This module solved this specialization if either the member or the type comes from the
             // module.
-            if member.module_id() != module_id && typ.module_id() != module_id {
+            if impl_key.ability_member.module_id() != module_id
+                && impl_key.opaque.module_id() != module_id
+            {
                 return None;
             }
-            let impl_key = ImplKey {
-                opaque: typ,
-                ability_member: member,
-            };
 
             let resolved_impl = match member_impl {
                 MemberImpl::Impl(impl_symbol) => {

crates/compiler/solve/src/solve.rs

@@ -1855,7 +1855,7 @@ fn check_ability_specialization(
         };
 
         abilities_store
-            .mark_implementation(impl_key.ability_member, impl_key.opaque, resolved_mark)
+            .mark_implementation(impl_key, resolved_mark)
             .expect("marked as a custom implementation, but not recorded as such");
     }
 }
@@ -2310,8 +2310,12 @@ fn get_specialization_lambda_set_ambient_function<P: Phase>(
             let opaque_home = opaque.module_id();
             let external_specialized_lset =
                 phase.with_module_abilities_store(opaque_home, |abilities_store| {
+            let impl_key = roc_can::abilities::ImplKey {
+                opaque,
+                ability_member,
+            };
                     let opt_specialization =
-                        abilities_store.get_implementation(ability_member, opaque);
+                        abilities_store.get_implementation(impl_key);
                     match (P::IS_LATE, opt_specialization) {
                         (false, None) => {
                             // doesn't specialize, we'll have reported an error for this

crates/compiler/solve/tests/solve_expr.rs

@@ -12,7 +12,10 @@ mod solve_expr {
     use crate::helpers::with_larger_debug_stack;
     use lazy_static::lazy_static;
     use regex::Regex;
-    use roc_can::traverse::{find_ability_member_and_owning_type_at, find_type_at};
+    use roc_can::{
+        abilities::ImplKey,
+        traverse::{find_ability_member_and_owning_type_at, find_type_at},
+    };
     use roc_load::LoadedModule;
     use roc_module::symbol::{Interns, ModuleId};
     use roc_problem::can::Problem;
@@ -367,12 +370,12 @@ mod solve_expr {
         }
 
         let known_specializations = abilities_store.iter_declared_implementations().filter_map(
-            |((member, typ), member_impl)| match member_impl {
+            |(impl_key, member_impl)| match member_impl {
                 MemberImpl::Impl(impl_symbol) => {
                     let specialization = abilities_store.specialization_info(*impl_symbol).expect(
                         "declared implementations should be resolved conclusively after solving",
                     );
-                    Some((member, typ, specialization.clone()))
+                    Some((impl_key, specialization.clone()))
                 }
                 MemberImpl::Derived | MemberImpl::Error => None,
             },
@@ -381,13 +384,17 @@ mod solve_expr {
         use std::collections::HashSet;
         let pretty_specializations = known_specializations
             .into_iter()
-            .map(|(member, typ, _)| {
-                let member_data = abilities_store.member_def(member).unwrap();
-                let member_str = member.as_str(&interns);
+            .map(|(impl_key, _)| {
+                let ImplKey {
+                    opaque,
+                    ability_member,
+                } = impl_key;
+                let member_data = abilities_store.member_def(ability_member).unwrap();
+                let member_str = ability_member.as_str(&interns);
                 let ability_str = member_data.parent_ability.as_str(&interns);
                 (
                     format!("{}:{}", ability_str, member_str),
-                    typ.as_str(&interns),
+                    opaque.as_str(&interns),
                 )
             })
             .collect::<HashSet<_>>();