Less zalsa calls

Author: Veykril

components/salsa-macro-rules/src/setup_interned_struct.rs

@@ -118,17 +118,17 @@ macro_rules! setup_interned_struct {
                 }
             }
 
-            impl salsa::plumbing::interned::Configuration for $StructWithStatic {
+            impl $zalsa::interned::Configuration for $StructWithStatic {
                 const DEBUG_NAME: &'static str = stringify!($Struct);
                 type Fields<'a> = $StructDataIdent<'a>;
                 type Struct<'db> = $Struct< $($db_lt_arg)? >;
                 fn struct_from_id<'db>(id: salsa::Id) -> Self::Struct<'db> {
-                    use salsa::plumbing::FromId;
+                    use $zalsa::FromId;
                     $Struct(<$Id>::from_id(id), std::marker::PhantomData)
                 }
 
                 fn deref_struct(s: Self::Struct<'_>) -> salsa::Id {
-                    use salsa::plumbing::AsId;
+                    use $zalsa::AsId;
                     s.0.as_id()
                 }
             }
@@ -217,7 +217,7 @@ macro_rules! setup_interned_struct {
                         // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
                         $Db: ?Sized + $zalsa::Database,
                     {
-                        let fields = $Configuration::ingredient(db).fields(db.as_dyn_database(), self);
+                        let fields = $Configuration::ingredient(db).data_zalsa(db.zalsa(), <$StructWithStatic as $zalsa::interned::Configuration>::deref_struct(self));
                         $zalsa::maybe_clone!(
                             $field_option,
                             $field_ty,
@@ -229,7 +229,7 @@ macro_rules! setup_interned_struct {
                 /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
                 pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                     $zalsa::with_attached_database(|db| {
-                        let fields = $Configuration::ingredient(db).fields(db.as_dyn_database(), this);
+                        let fields = $Configuration::ingredient(db).data_zalsa(db.zalsa(), <$StructWithStatic as $zalsa::interned::Configuration>::deref_struct(this));
                         let mut f = f.debug_struct(stringify!($Struct));
                         $(
                             let f = f.field(stringify!($field_id), &fields.$field_index);

components/salsa-macro-rules/src/setup_tracked_fn.rs

@@ -217,12 +217,13 @@ macro_rules! setup_tracked_fn {
                     $($cycle_recovery_fn)*(db, value, count, $($input_id),*)
                 }
 
-                fn id_to_input<$db_lt>(db: &$db_lt Self::DbView, key: salsa::Id) -> Self::Input<$db_lt> {
+                #[inline]
+                fn id_to_input<$db_lt>(db: &$db_lt Self::DbView, zalsa: &$db_lt $zalsa::Zalsa, key: salsa::Id) -> Self::Input<$db_lt> {
                     $zalsa::macro_if! {
                         if $needs_interner {
-                            $Configuration::intern_ingredient(db).data(db.as_dyn_database(), key).clone()
+                            $Configuration::intern_ingredient(db).data_zalsa(zalsa, key).clone()
                         } else {
-                            $zalsa::FromIdWithDb::from_id(key, db)
+                            $zalsa::FromIdWithDb::from_id_zalsa(key, zalsa)
                         }
                     }
                 }

components/salsa-macros/src/supertype.rs

@@ -61,8 +61,12 @@ fn enum_impl(enum_item: syn::ItemEnum) -> syn::Result<TokenStream> {
             #[inline]
             fn from_id(__id: zalsa::Id, __db: &(impl ?Sized + zalsa::Database)) -> Self {
                 let __zalsa = __db.zalsa();
-                let __type_id = __zalsa.lookup_page_type_id(__id);
-                <Self as zalsa::SalsaStructInDb>::cast(__id, __type_id).expect("invalid enum variant")
+                Self::from_id_zalsa( __id,__zalsa)
+            }
+            #[inline]
+            fn from_id_zalsa(id: zalsa::Id, zalsa: &zalsa::Zalsa) -> Self {
+                let type_id = zalsa.lookup_page_type_id(id);
+                <Self as zalsa::SalsaStructInDb>::cast(id, type_id).expect("invalid enum variant")
             }
         }
     };

src/function.rs

@@ -60,7 +60,7 @@ pub trait Configuration: Any {
 
     /// Convert from the id used internally to the value that execute is expecting.
     /// This is a no-op if the input to the function is a salsa struct.
-    fn id_to_input(db: &Self::DbView, key: Id) -> Self::Input<'_>;
+    fn id_to_input<'db>(db: &'db Self::DbView, zalsa: &'db Zalsa, key: Id) -> Self::Input<'db>;
 
     /// Invoked when we need to compute the value for the given key, either because we've never
     /// computed it before or because the old one relied on inputs that have changed.

src/function/execute.rs

@@ -57,7 +57,7 @@ where
 
                 // Query was not previously executed, or value is potentially
                 // stale, or value is absent. Let's execute!
-                let mut new_value = C::execute(db, C::id_to_input(db, id));
+                let mut new_value = C::execute(db, C::id_to_input(db, zalsa, id));
                 let mut revisions = active_query.pop();
 
                 // Did the new result we got depend on our own provisional value, in a cycle?
@@ -105,7 +105,7 @@ where
                             db,
                             &new_value,
                             iteration_count,
-                            C::id_to_input(db, id),
+                            C::id_to_input(db, zalsa, id),
                         ) {
                             crate::CycleRecoveryAction::Iterate => {
                                 tracing::debug!(
@@ -169,7 +169,7 @@ where
 
             // Query was not previously executed, or value is potentially
             // stale, or value is absent. Let's execute!
-            let new_value = C::execute(db, C::id_to_input(db, id));
+            let new_value = C::execute(db, C::id_to_input(db, zalsa, id));
             let revisions = active_query.pop();
 
             (new_value, revisions)

src/function/memo.rs

@@ -10,7 +10,7 @@ use crate::function::{Configuration, IngredientImpl};
 use crate::key::DatabaseKeyIndex;
 use crate::revision::AtomicRevision;
 use crate::table::memo::MemoTable;
-use crate::zalsa::{MemoIngredientIndex, Zalsa};
+use crate::zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase};
 use crate::zalsa_local::{QueryOrigin, QueryRevisions};
 use crate::{Event, EventKind, Id, Revision};
 
@@ -113,7 +113,9 @@ impl<C: Configuration> IngredientImpl<C> {
         key: Id,
     ) -> Option<C::Output<'db>> {
         match C::CYCLE_STRATEGY {
-            CycleRecoveryStrategy::Fixpoint => Some(C::cycle_initial(db, C::id_to_input(db, key))),
+            CycleRecoveryStrategy::Fixpoint => {
+                Some(C::cycle_initial(db, C::id_to_input(db, db.zalsa(), key)))
+            }
             CycleRecoveryStrategy::Panic => None,
         }
     }

src/id.rs

@@ -72,12 +72,14 @@ pub trait FromId: AsId + Copy + Eq + Hash {
 }
 
 impl AsId for Id {
+    #[inline]
     fn as_id(&self) -> Id {
         *self
     }
 }
 
 impl FromId for Id {
+    #[inline]
     fn from_id(id: Id) -> Self {
         id
     }
@@ -87,11 +89,17 @@ impl FromId for Id {
 /// so they use this trait instead, that has a blanket implementation for `FromId`.
 pub trait FromIdWithDb: AsId + Copy + Eq + Hash {
     fn from_id(id: Id, db: &(impl ?Sized + Database)) -> Self;
+    #[doc(hidden)]
+    fn from_id_zalsa(id: Id, zalsa: &crate::zalsa::Zalsa) -> Self;
 }
 
 impl<T: FromId> FromIdWithDb for T {
     #[inline]
-    fn from_id(id: Id, _db: &(impl ?Sized + Database)) -> Self {
+    fn from_id(id: Id, _: &(impl ?Sized + Database)) -> Self {
+        FromId::from_id(id)
+    }
+    #[inline]
+    fn from_id_zalsa(id: Id, _: &crate::zalsa::Zalsa) -> Self {
         FromId::from_id(id)
     }
 }

src/input.rs

@@ -108,7 +108,7 @@ impl<C: Configuration> IngredientImpl<C> {
             })
         });
 
-        FromIdWithDb::from_id(id, db)
+        FromIdWithDb::from_id_zalsa(id, zalsa)
     }
 
     /// Change the value of the field `field_index` to a new value.

src/interned.rs

@@ -335,7 +335,11 @@ where
     /// Rarely used since end-users generally carry a struct with a pointer directly
     /// to the interned item.
     pub fn data<'db>(&'db self, db: &'db dyn Database, id: Id) -> &'db C::Fields<'db> {
-        let zalsa = db.zalsa();
+        self.data_zalsa(db.zalsa(), id)
+    }
+
+    #[doc(hidden)]
+    pub fn data_zalsa<'db>(&'db self, zalsa: &'db Zalsa, id: Id) -> &'db C::Fields<'db> {
         let internal_data = zalsa.table().get::<Value<C>>(id);
         let last_changed_revision = zalsa.last_changed_revision(internal_data.durability());
 
@@ -350,7 +354,7 @@ where
     /// Lookup the fields from an interned struct.
     /// Note that this is not "leaking" since no dependency edge is required.
     pub fn fields<'db>(&'db self, db: &'db dyn Database, s: C::Struct<'db>) -> &'db C::Fields<'db> {
-        self.data(db, C::deref_struct(s))
+        self.data_zalsa(db.zalsa(), C::deref_struct(s))
     }
 
     pub fn reset(&mut self, db: &mut dyn Database) {

tests/interned-structs_self_ref.rs

@@ -164,20 +164,20 @@ const _: () = {
         where
             Db_: ?Sized + zalsa_::Database,
         {
-            let fields = Configuration_::ingredient(db).fields(db.as_dyn_database(), self);
+            let fields = Configuration_::ingredient(db).data_zalsa(db.zalsa(), self.0);
             std::clone::Clone::clone((&fields.0))
         }
         fn other<Db_>(self, db: &'db Db_) -> InternedString<'db>
         where
             Db_: ?Sized + zalsa_::Database,
         {
-            let fields = Configuration_::ingredient(db).fields(db.as_dyn_database(), self);
+            let fields = Configuration_::ingredient(db).data_zalsa(db.zalsa(), self.0);
             std::clone::Clone::clone((&fields.1))
         }
         #[doc = r" Default debug formatting for this struct (may be useful if you define your own `Debug` impl)"]
         pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             zalsa_::with_attached_database(|db| {
-                let fields = Configuration_::ingredient(db).fields(db.as_dyn_database(), this);
+                let fields = Configuration_::ingredient(db).data_zalsa(db.zalsa(), this.0);
                 let mut f = f.debug_struct("InternedString");
                 let f = f.field("data", &fields.0);
                 let f = f.field("other", &fields.1);