implement ability to get readable debug output for DatabaseKeyIndex

components/salsa-macros/src/database_storage.rs

@@ -150,6 +150,7 @@ pub(crate) fn database(args: TokenStream, input: TokenStream) -> TokenStream {
     // ANCHOR_END:DatabaseStorageTypes
 
     // ANCHOR:DatabaseOps
+    let mut fmt_ops = proc_macro2::TokenStream::new();
     let mut maybe_changed_ops = proc_macro2::TokenStream::new();
     let mut for_each_ops = proc_macro2::TokenStream::new();
     for ((QueryGroup { group_path }, group_storage), group_index) in query_groups
@@ -157,6 +158,13 @@ pub(crate) fn database(args: TokenStream, input: TokenStream) -> TokenStream {
         .zip(&query_group_storage_names)
         .zip(0_u16..)
     {
+        fmt_ops.extend(quote! {
+            #group_index => {
+                let storage: &#group_storage =
+                    <Self as salsa::plumbing::HasQueryGroup<#group_path>>::group_storage(self);
+                storage.fmt_index(self, input, fmt)
+            }
+        });
         maybe_changed_ops.extend(quote! {
             #group_index => {
                 let storage: &#group_storage =
@@ -172,6 +180,17 @@ pub(crate) fn database(args: TokenStream, input: TokenStream) -> TokenStream {
     }
     output.extend(quote! {
         impl salsa::plumbing::DatabaseOps for #database_name {
+            fn fmt_index(
+                &self,
+                input: salsa::DatabaseKeyIndex,
+                fmt: &mut std::fmt::Formatter<'_>,
+            ) -> std::fmt::Result {
+                match input.group_index() {
+                    #fmt_ops
+                    i => panic!("salsa: invalid group index {}", i)
+                }
+            }
+
             fn maybe_changed_since(
                 &self,
                 input: salsa::DatabaseKeyIndex,

components/salsa-macros/src/query_group.rs

@@ -471,6 +471,17 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
         }
     });
 
+    let mut fmt_ops = proc_macro2::TokenStream::new();
+    for (Query { fn_name, .. }, query_index) in non_transparent_queries().zip(0_u16..) {
+        fmt_ops.extend(quote! {
+            #query_index => {
+                salsa::plumbing::QueryStorageOps::fmt_index(
+                    &*self.#fn_name, db, input, fmt,
+                )
+            }
+        });
+    }
+
     let mut maybe_changed_ops = proc_macro2::TokenStream::new();
     for (Query { fn_name, .. }, query_index) in non_transparent_queries().zip(0_u16..) {
         maybe_changed_ops.extend(quote! {
@@ -521,6 +532,18 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
             DB__: #trait_name + #requires,
             DB__: salsa::plumbing::HasQueryGroup<#group_struct>,
         {
+            #trait_vis fn fmt_index(
+                &self,
+                db: &DB__,
+                input: salsa::DatabaseKeyIndex,
+                fmt: &mut std::fmt::Formatter<'_>,
+            ) -> std::fmt::Result {
+                match input.query_index() {
+                    #fmt_ops
+                    i => panic!("salsa: impossible query index {}", i),
+                }
+            }
+
             #trait_vis fn maybe_changed_since(
                 &self,
                 db: &DB__,

src/derived.rs

@@ -132,6 +132,19 @@ where
         }
     }
 
+    fn fmt_index(
+        &self,
+        _db: &DB,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        assert_eq!(index.group_index, self.group_index);
+        assert_eq!(index.query_index, Q::QUERY_INDEX);
+        let slot_map = self.slot_map.read();
+        let key = slot_map.get_index(index.key_index as usize).unwrap().0;
+        write!(fmt, "{}({:?})", Q::QUERY_NAME, key)
+    }
+
     fn maybe_changed_since(&self, db: &DB, input: DatabaseKeyIndex, revision: Revision) -> bool {
         assert_eq!(input.group_index, self.group_index);
         assert_eq!(input.query_index, Q::QUERY_INDEX);

src/input.rs

@@ -70,6 +70,19 @@ where
         }
     }
 
+    fn fmt_index(
+        &self,
+        _db: &DB,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        assert_eq!(index.group_index, self.group_index);
+        assert_eq!(index.query_index, Q::QUERY_INDEX);
+        let slot_map = self.slots.read();
+        let key = slot_map.get_index(index.key_index as usize).unwrap().0;
+        write!(fmt, "{}({:?})", Q::QUERY_NAME, key)
+    }
+
     fn maybe_changed_since(&self, db: &DB, input: DatabaseKeyIndex, revision: Revision) -> bool {
         assert_eq!(input.group_index, self.group_index);
         assert_eq!(input.query_index, Q::QUERY_INDEX);

src/interned.rs

@@ -300,6 +300,19 @@ where
         }
     }
 
+    fn fmt_index(
+        &self,
+        db: &DB,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        assert_eq!(index.group_index, self.group_index);
+        assert_eq!(index.query_index, Q::QUERY_INDEX);
+        let intern_id = InternId::from(index.key_index);
+        let slot = self.lookup_value(db, intern_id);
+        write!(fmt, "{}({:?})", Q::QUERY_NAME, slot.value)
+    }
+
     fn maybe_changed_since(&self, db: &DB, input: DatabaseKeyIndex, revision: Revision) -> bool {
         assert_eq!(input.group_index, self.group_index);
         assert_eq!(input.query_index, Q::QUERY_INDEX);
@@ -416,6 +429,17 @@ where
         }
     }
 
+    fn fmt_index(
+        &self,
+        db: &DB,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        let group_storage = <DB as HasQueryGroup<Q::Group>>::group_storage(db);
+        let interned_storage = IQ::query_storage(group_storage);
+        interned_storage.fmt_index(db, index, fmt)
+    }
+
     fn maybe_changed_since(&self, db: &DB, input: DatabaseKeyIndex, revision: Revision) -> bool {
         let group_storage = <DB as HasQueryGroup<Q::Group>>::group_storage(db);
         let interned_storage = IQ::query_storage(group_storage);

src/lib.rs

@@ -438,6 +438,33 @@ impl DatabaseKeyIndex {
     pub fn key_index(self) -> u32 {
         self.key_index
     }
+
+    /// Returns a type that gives a user-readable debug output.
+    /// Use like `println!("{:?}", index.debug(db))`.
+    pub fn debug<D: ?Sized>(self, db: &D) -> impl std::fmt::Debug + '_
+    where
+        D: plumbing::DatabaseOps,
+    {
+        DatabaseKeyIndexDebug { index: self, db }
+    }
+}
+
+/// Helper type for `DatabaseKeyIndex::debug`
+struct DatabaseKeyIndexDebug<'me, D: ?Sized>
+where
+    D: plumbing::DatabaseOps,
+{
+    index: DatabaseKeyIndex,
+    db: &'me D,
+}
+
+impl<D: ?Sized> std::fmt::Debug for DatabaseKeyIndexDebug<'_, D>
+where
+    D: plumbing::DatabaseOps,
+{
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.db.fmt_index(self.index, fmt)
+    }
 }
 
 /// Trait implements by all of the "special types" associated with

src/plumbing.rs

@@ -45,6 +45,13 @@ pub trait DatabaseStorageTypes: Sized {
 
 /// Internal operations that the runtime uses to operate on the database.
 pub trait DatabaseOps: Sized {
+    /// Formats a database key index in a human readable fashion.
+    fn fmt_index(
+        &self,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result;
+
     /// True if the computed value for `input` may have changed since `revision`.
     fn maybe_changed_since(&self, input: DatabaseKeyIndex, revision: Revision) -> bool;
 
@@ -147,6 +154,14 @@ where
 {
     fn new(group_index: u16) -> Self;
 
+    /// Format a database key index in a suitable way.
+    fn fmt_index(
+        &self,
+        db: &DB,
+        index: DatabaseKeyIndex,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result;
+
     /// True if the value of `input`, which must be from this query, may have
     /// changed since the given revision.
     fn maybe_changed_since(&self, db: &DB, input: DatabaseKeyIndex, revision: Revision) -> bool;