Fix and intern implementors list, bump to 0.1.18

Author: gavinleroy

crates/argus-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "argus-cli"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 authors = ["Gavin Gray <gavinleroy6@gmail.com>"]
 repository = "https://github.com/cognitive-engineering-lab/argus"
@@ -10,8 +10,8 @@ license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-argus-lib = { version = "0.1.17", path = "../argus" }
-argus-ext = { version = "0.1.17", path = "../argus-ext" }
+argus-lib = { version = "0.1.18", path = "../argus" }
+argus-ext = { version = "0.1.18", path = "../argus-ext" }
 rustc_plugin = "=0.13.0-nightly-2025-03-03"
 
 rustc_utils.workspace = true

crates/argus-ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "argus-ext"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 authors = ["Gavin Gray <gavinleroy6@gmail.com>"]
 repository = "https://github.com/cognitive-engineering-lab/argus"

crates/argus-ext/src/rustc/mod.rs

@@ -94,10 +94,9 @@ pub trait InferCtxtExt<'tcx> {
     error: ty::Predicate<'tcx>,
   ) -> bool;
 
-  /// Private in TypeErrorCtxt
-  fn find_similar_impl_candidates(
+  fn all_impls(
     &self,
-    trait_pred: ty::PolyTraitPredicate<'tcx>,
+    def_id: rustc_span::def_id::DefId,
   ) -> Vec<ImplCandidate<'tcx>>;
 
   /// Public (wrapping for local `CandidateSimilarity`)
@@ -250,13 +249,13 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
     }
   }
 
-  fn find_similar_impl_candidates(
+  fn all_impls(
     &self,
-    trait_pred: ty::PolyTraitPredicate<'tcx>,
+    def_id: rustc_span::def_id::DefId,
   ) -> Vec<ImplCandidate<'tcx>> {
-    let mut candidates: Vec<_> = self
+    self
       .tcx
-      .all_impls(trait_pred.def_id())
+      .all_impls(def_id)
       .filter_map(|def_id| {
         let imp = self.tcx.impl_trait_header(def_id).unwrap();
 
@@ -266,34 +265,13 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
           return None;
         }
 
-        let imp = imp.trait_ref.skip_binder();
-
-        self
-          .fuzzy_match_tys(
-            trait_pred.skip_binder().self_ty(),
-            imp.self_ty(),
-            false,
-          )
-          .map(|similarity| ImplCandidate {
-            trait_ref: imp,
-            similarity,
-            impl_def_id: def_id,
-          })
+        Some(ImplCandidate {
+          trait_ref: imp.trait_ref.skip_binder(),
+          similarity: CandidateSimilarity::Other,
+          impl_def_id: def_id,
+        })
       })
-      .collect();
-
-    if candidates
-      .iter()
-      .any(|c| matches!(c.similarity, CandidateSimilarity::Exact { .. }))
-    {
-      // If any of the candidates is a perfect match, we don't want to show all of them.
-      // This is particularly relevant for the case of numeric types (as they all have the
-      // same category).
-      candidates
-        .retain(|c| matches!(c.similarity, CandidateSimilarity::Exact { .. }));
-    }
-
-    candidates
+      .collect()
   }
 
   fn fuzzy_match_tys(

crates/argus-ser-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "argus-ser-macros"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 authors = ["Gavin Gray <gavinleroy6@gmail.com>"]
 repository = "https://github.com/cognitive-engineering-lab/argus"

crates/argus-ser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "argus-ser"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 authors = ["Gavin Gray <gavinleroy6@gmail.com>"]
 repository = "https://github.com/cognitive-engineering-lab/argus"
@@ -28,8 +28,8 @@ ts-rs = { version = "7.1.1", features = [
   "no-serde-warnings",
 ], optional = true }
 
-argus-ser-macros = { version = "0.1.17", path = "../argus-ser-macros" }
-argus-ext = { version = "0.1.17", path = "../argus-ext" }
+argus-ser-macros = { version = "0.1.18", path = "../argus-ser-macros" }
+argus-ext = { version = "0.1.18", path = "../argus-ext" }
 
 [dev-dependencies]
 argus-ser = { path = ".", features = ["testing"] }

crates/argus-ser/src/interner.rs

@@ -1,12 +1,11 @@
-use std::collections::HashMap; // FIXME: change back to above
 use std::{
   cell::RefCell,
   cmp::{Eq, PartialEq},
   hash::Hash,
 };
 
 use index_vec::{Idx, IndexVec};
-// use rustc_data_structures::fx::FxHashMap as HashMap;
+use rustc_data_structures::fx::FxHashMap as HashMap;
 use rustc_middle::ty;
 
 crate::define_idx! {
@@ -62,3 +61,13 @@ where
     self.values
   }
 }
+
+trait FxHashExt {
+  fn with_capacity(capacity: usize) -> Self;
+}
+
+impl<K, V> FxHashExt for HashMap<K, V> {
+  fn with_capacity(capacity: usize) -> Self {
+    HashMap::with_capacity_and_hasher(capacity, Default::default())
+  }
+}

crates/argus/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "argus-lib"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 authors = ["Gavin Gray <gavinleroy6@gmail.com>"]
 repository = "https://github.com/cognitive-engineering-lab/argus"
@@ -22,8 +22,8 @@ serde.workspace = true
 serde_json.workspace = true
 itertools.workspace = true
 
-argus-ext = { version = "0.1.17", path = "../argus-ext" }
-argus-ser = { version = "0.1.17", path = "../argus-ser" }
+argus-ext = { version = "0.1.18", path = "../argus-ext" }
+argus-ser = { version = "0.1.18", path = "../argus-ser" }
 index_vec = { version = "0.1.3", features = ["serde"] }
 smallvec = "1.14.0"
 indexmap = { version = "2.2", features = ["serde"] }

crates/argus/src/proof_tree/hash_map.rs

@@ -0,0 +1,85 @@
+//! Wrapper around `FxHashMap` that implements `ts_rs::TS`
+use std::{
+  fmt::Debug,
+  ops::{Deref, DerefMut},
+};
+
+use rustc_data_structures::fx::FxHashMap;
+use serde::Serialize;
+#[cfg(feature = "testing")]
+use ts_rs::TS;
+
+use super::topology::Idx;
+
+#[cfg(not(feature = "testing"))]
+pub trait AllTheThings: Debug + Serialize {}
+
+#[cfg(not(feature = "testing"))]
+impl<T> AllTheThings for T where T: Debug + Serialize {}
+
+#[cfg(feature = "testing")]
+pub trait AllTheThings: Debug + Serialize + TS {}
+
+#[cfg(feature = "testing")]
+impl<T> AllTheThings for T where T: Debug + Serialize + TS {}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct HashMap<K: Idx, V: AllTheThings>(FxHashMap<K, V>);
+
+impl<K: Idx, V: AllTheThings> Deref for HashMap<K, V> {
+  type Target = FxHashMap<K, V>;
+
+  fn deref(&self) -> &Self::Target {
+    &self.0
+  }
+}
+
+impl<K: Idx, V: AllTheThings> DerefMut for HashMap<K, V> {
+  fn deref_mut(&mut self) -> &mut Self::Target {
+    &mut self.0
+  }
+}
+
+impl<K: Idx, V: AllTheThings> Default for HashMap<K, V> {
+  fn default() -> Self {
+    HashMap(FxHashMap::default())
+  }
+}
+
+#[cfg(feature = "testing")]
+impl<K: Idx, V: AllTheThings> TS for HashMap<K, V> {
+  fn name() -> String {
+    "Record".to_owned()
+  }
+
+  fn name_with_type_args(args: Vec<String>) -> String {
+    assert_eq!(
+      args.len(),
+      2,
+      "called HashMap::name_with_type_args with {} args",
+      args.len()
+    );
+    format!("Record<{}, {}>", args[0], args[1])
+  }
+
+  fn inline() -> String {
+    format!("Record<{}, {}>", K::inline(), V::inline())
+  }
+
+  fn dependencies() -> Vec<ts_rs::Dependency>
+  where
+    Self: 'static,
+  {
+    [
+      ts_rs::Dependency::from_ty::<K>(),
+      ts_rs::Dependency::from_ty::<V>(),
+    ]
+    .into_iter()
+    .flatten()
+    .collect()
+  }
+
+  fn transparent() -> bool {
+    true
+  }
+}

crates/argus/src/proof_tree/interners.rs

@@ -28,10 +28,18 @@ use crate::{
 
 pub struct Interners {
   goals: Interner<(Hash64, ResultIdx), GoalIdx, GoalData>,
+  implementors: Interner<DefId, ImplementorsIdx, Implementors>,
   candidates: Interner<CanKey, CandidateIdx, CandidateData>,
   results: Interner<EvaluationResult, ResultIdx, ResultData>,
 }
 
+pub struct InternedData {
+  pub goals: IndexVec<GoalIdx, GoalData>,
+  pub implementors: IndexVec<ImplementorsIdx, Implementors>,
+  pub candidates: IndexVec<CandidateIdx, CandidateData>,
+  pub results: IndexVec<ResultIdx, ResultData>,
+}
+
 #[derive(PartialEq, Eq, Hash)]
 enum CanKey {
   Impl(DefId),
@@ -43,23 +51,19 @@ impl Interners {
   pub fn default() -> Self {
     Self {
       goals: Interner::default(),
+      implementors: Interner::default(),
       candidates: Interner::default(),
       results: Interner::default(),
     }
   }
 
-  pub fn take(
-    self,
-  ) -> (
-    IndexVec<GoalIdx, GoalData>,
-    IndexVec<CandidateIdx, CandidateData>,
-    IndexVec<ResultIdx, ResultData>,
-  ) {
-    (
-      self.goals.consume(),
-      self.candidates.consume(),
-      self.results.consume(),
-    )
+  pub fn take(self) -> InternedData {
+    InternedData {
+      goals: self.goals.consume(),
+      implementors: self.implementors.consume(),
+      candidates: self.candidates.consume(),
+      results: self.results.consume(),
+    }
   }
 
   // NOTE: used in `test_utils`.
@@ -74,10 +78,6 @@ impl Interners {
     self.candidates.get_data(&c).expect("missing candidate idx")
   }
 
-  pub fn mk_result_node(&mut self, result: EvaluationResult) -> ProofNode {
-    ProofNode::pack(ProofNodeUnpacked::Result(self.intern_result(result)))
-  }
-
   pub fn mk_goal_node(&mut self, goal: &InspectGoal) -> ProofNode {
     let infcx = goal.infcx();
     let result_idx = self.intern_result(goal.result());
@@ -213,4 +213,63 @@ impl Interners {
 
     self.candidates.insert_no_key(CandidateData::from(string))
   }
+
+  pub(super) fn intern_implementors(
+    &mut self,
+    infcx: &InferCtxt,
+    def_id: DefId,
+    tp: ty::PolyTraitPredicate,
+  ) -> ImplementorsIdx {
+    use argus_ext::{rustc::InferCtxtExt, ty::ImplCandidateExt};
+
+    if let Some(i) = self.implementors.get_idx(&def_id) {
+      return i;
+    }
+
+    let identity_trait_ref =
+      ty::TraitRef::identity(infcx.tcx, tp.skip_binder().trait_ref.def_id);
+
+    let trait_ = ser::TraitRefPrintOnlyTraitPathDef(identity_trait_ref);
+    let trait_ = tls::unsafe_access_interner(|ty_interner| {
+      ser::to_value_expect(infcx, ty_interner, &trait_)
+    });
+
+    // Gather all impls
+    let mut impls = vec![];
+    let mut inductive_impls = vec![];
+
+    let mut impl_candidates = infcx.all_impls(tp.def_id());
+
+    // HACK: Sort the `impl_candidates` by the number of *type* parameters. We use this
+    // as a proxy for complexity, that is, complexity of reading the impl, we want
+    // to show Argus users "simpler" impls first.
+    // This probably shouldn't happen here, as it's a concern of the frontend, but this is
+    // the last place we have all that information.
+    macro_rules! sort_by_count {
+      ($field:ident, $vec:expr) => {
+        $vec.sort_by_key(|c| {
+          infcx.tcx.generics_of(c.impl_def_id).own_counts().$field
+        })
+      };
+    }
+    sort_by_count!(types, impl_candidates);
+    sort_by_count!(lifetimes, impl_candidates);
+
+    for can in impl_candidates {
+      let can_idx = self.intern_impl(infcx, can.impl_def_id);
+      if can.is_inductive(infcx.tcx) {
+        inductive_impls.push(can_idx);
+      } else {
+        impls.push(can_idx);
+      }
+    }
+
+    let impls = Implementors {
+      trait_,
+      impls,
+      inductive_impls,
+    };
+
+    self.implementors.insert(def_id, impls)
+  }
 }