From 5adb3c9ab3ff2fa5ed7787c6b65861d351ddbfef Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Sat, 30 Oct 2021 06:53:59 -0400
Subject: [PATCH] add debug methods that carry db

---
 src/lib.rs | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index 72c3aa9e..28bbab0f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,6 +114,17 @@ pub struct Event {
     pub kind: EventKind,
 }
 
+impl Event {
+    /// 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,
+    {
+        EventDebug { event: self, db }
+    }
+}
+
 impl fmt::Debug for Event {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Event")
@@ -123,6 +134,26 @@ impl fmt::Debug for Event {
     }
 }
 
+struct EventDebug<'db, D: ?Sized>
+where
+    D: plumbing::DatabaseOps,
+{
+    event: Event,
+    db: &'db D,
+}
+
+impl<'db, D: ?Sized> fmt::Debug for EventDebug<'db, D>
+where
+    D: plumbing::DatabaseOps,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("Event")
+            .field("runtime_id", &self.event.runtime_id)
+            .field("kind", &self.event.kind.debug(self.db))
+            .finish()
+    }
+}
+
 /// An enum identifying the various kinds of events that can occur.
 pub enum EventKind {
     /// Occurs when we found that all inputs to a memoized value are
@@ -165,6 +196,17 @@ pub enum EventKind {
     WillCheckCancellation,
 }
 
+impl EventKind {
+    /// Returns a type that gives a user-readable debug output.
+    /// Use like `println!("{:?}", index.debug(db))`.
+    pub fn debug<'me, D: ?Sized>(&'me self, db: &'me D) -> impl std::fmt::Debug + 'me
+    where
+        D: plumbing::DatabaseOps,
+    {
+        EventKindDebug { kind: self, db }
+    }
+}
+
 impl fmt::Debug for EventKind {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -189,6 +231,41 @@ impl fmt::Debug for EventKind {
     }
 }
 
+struct EventKindDebug<'me, D: ?Sized>
+where
+    D: plumbing::DatabaseOps,
+{
+    kind: &'me EventKind,
+    db: &'me D,
+}
+
+impl<'me, D: ?Sized> fmt::Debug for EventKindDebug<'me, D>
+where
+    D: plumbing::DatabaseOps,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.kind {
+            EventKind::DidValidateMemoizedValue { database_key } => fmt
+                .debug_struct("DidValidateMemoizedValue")
+                .field("database_key", &database_key.debug(self.db))
+                .finish(),
+            EventKind::WillBlockOn {
+                other_runtime_id,
+                database_key,
+            } => fmt
+                .debug_struct("WillBlockOn")
+                .field("other_runtime_id", &other_runtime_id)
+                .field("database_key", &database_key.debug(self.db))
+                .finish(),
+            EventKind::WillExecute { database_key } => fmt
+                .debug_struct("WillExecute")
+                .field("database_key", &database_key.debug(self.db))
+                .finish(),
+            EventKind::WillCheckCancellation => fmt.debug_struct("WillCheckCancellation").finish(),
+        }
+    }
+}
+
 /// Indicates a database that also supports parallel query
 /// evaluation. All of Salsa's base query support is capable of
 /// parallel execution, but for it to work, your query key/value types