Have salsa not depend on salsa-macros (#750)

That way salsa can build without having to build the proc-macro ecosystem, improving build times for dependants of salsa

Author: Veykril

Cargo.toml

@@ -10,7 +10,7 @@ description = "A generic framework for on-demand, incrementalized computation (e
 
 [dependencies]
 salsa-macro-rules = { version = "0.18.0", path = "components/salsa-macro-rules" }
-salsa-macros = { version = "0.18.0", path = "components/salsa-macros" }
+salsa-macros = { version = "0.18.0", path = "components/salsa-macros", optional = true }
 
 boxcar = "0.2.9"
 crossbeam-queue = "0.3.11"
@@ -22,7 +22,7 @@ parking_lot = "0.12"
 portable-atomic = "1"
 rustc-hash = "2"
 smallvec = "1"
-tracing = "0.1"
+tracing = { version = "0.1", default-features = false, features = ["std"] }
 
 # parallel map
 rayon = { version = "1.10.0", optional = true }
@@ -31,9 +31,17 @@ rayon = { version = "1.10.0", optional = true }
 compact_str = { version = "0.8", optional = true }
 
 [features]
-default = ["salsa_unstable", "rayon"]
+default = ["salsa_unstable", "rayon", "macros"]
 # FIXME: remove `salsa_unstable` before 1.0.
 salsa_unstable = []
+macros = ["dep:salsa-macros"]
+
+# This interlocks the `salsa-macros` and `salsa` versions together
+# preventing scenarios where they could diverge in a given project
+# which may ultimately result in odd issues due to the proc-macro
+# output mismatching with the declarative macro inputs
+[target.'cfg(any())'.dependencies]
+salsa-macros = { version = "=0.18.0", path = "components/salsa-macros" }
 
 [dev-dependencies]
 # examples

src/database.rs

@@ -7,7 +7,6 @@ use crate::{
 
 /// The trait implemented by all Salsa databases.
 /// You can create your own subtraits of this trait using the `#[salsa::db]`(`crate::db`) procedural macro.
-#[crate::db]
 pub trait Database: Send + AsDynDatabase + Any + ZalsaDatabase {
     /// This function is invoked by the salsa runtime at various points during execution.
     /// You can customize what happens by implementing the [`UserData`][] trait.
@@ -89,6 +88,21 @@ pub trait Database: Send + AsDynDatabase + Any + ZalsaDatabase {
     {
         crate::attach::attach(self, || op(self))
     }
+
+    #[doc(hidden)]
+    fn zalsa_register_downcaster(&self) {
+        // The no-op downcaster is special cased in view caster construction.
+    }
+
+    #[doc(hidden)]
+    #[inline(always)]
+    unsafe fn downcast(db: &dyn Database) -> &dyn Database
+    where
+        Self: Sized,
+    {
+        // No-op
+        db
+    }
 }
 
 /// Upcast to a `dyn Database`.

src/database_impl.rs

@@ -1,6 +1,5 @@
-use crate::{self as salsa, Database, Event, Storage};
+use crate::{storage::HasStorage, Database, Event, Storage};
 
-#[salsa::db]
 /// Default database implementation that you can use if you don't
 /// require any custom user data.
 #[derive(Default, Clone)]
@@ -19,10 +18,23 @@ impl DatabaseImpl {
     }
 }
 
-#[salsa::db]
 impl Database for DatabaseImpl {
     /// Default behavior: tracing debug log the event.
     fn salsa_event(&self, event: &dyn Fn() -> Event) {
         tracing::debug!("salsa_event({:?})", event());
     }
 }
+
+// # Safety
+//
+// The `storage` and `storage_mut` fields return a reference to the same
+// storage field owned by `self`.
+unsafe impl HasStorage for DatabaseImpl {
+    fn storage(&self) -> &Storage<Self> {
+        &self.storage
+    }
+
+    fn storage_mut(&mut self) -> &mut Storage<Self> {
+        &mut self.storage
+    }
+}

src/lib.rs

@@ -1,7 +1,5 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-extern crate self as salsa;
-
 mod accumulator;
 mod active_query;
 mod array;
@@ -54,13 +52,8 @@ pub use self::zalsa::IngredientIndex;
 pub use crate::attach::with_attached_database;
 #[cfg(feature = "rayon")]
 pub use par_map::par_map;
-pub use salsa_macros::accumulator;
-pub use salsa_macros::db;
-pub use salsa_macros::input;
-pub use salsa_macros::interned;
-pub use salsa_macros::tracked;
-pub use salsa_macros::Supertype;
-pub use salsa_macros::Update;
+#[cfg(feature = "macros")]
+pub use salsa_macros::{accumulator, db, input, interned, tracked, Supertype, Update};
 
 pub mod prelude {
     pub use crate::Accumulator;

src/views.rs

@@ -24,6 +24,22 @@ struct ViewCaster {
     cast: ErasedDatabaseDownCasterSig,
 }
 
+impl ViewCaster {
+    fn new<DbView: ?Sized + Any>(func: unsafe fn(&dyn Database) -> &DbView) -> ViewCaster {
+        ViewCaster {
+            target_type_id: TypeId::of::<DbView>(),
+            type_name: std::any::type_name::<DbView>(),
+            // SAFETY: We are type erasing for storage, taking care of unerasing before we call
+            // the function pointer.
+            cast: unsafe {
+                std::mem::transmute::<DatabaseDownCasterSig<DbView>, ErasedDatabaseDownCasterSig>(
+                    func,
+                )
+            },
+        }
+    }
+}
+
 type ErasedDatabaseDownCasterSig = unsafe fn(&dyn Database) -> *const ();
 type DatabaseDownCasterSig<DbView> = unsafe fn(&dyn Database) -> &DbView;
 
@@ -55,18 +71,7 @@ impl Views {
         let source_type_id = TypeId::of::<Db>();
         let view_casters = boxcar::Vec::new();
         // special case the no-op transformation, that way we skip out on reconstructing the wide pointer
-        view_casters.push(ViewCaster {
-            target_type_id: TypeId::of::<dyn Database>(),
-            type_name: std::any::type_name::<dyn Database>(),
-            // SAFETY: We are type erasing for storage, taking care of unerasing before we call
-            // the function pointer.
-            cast: unsafe {
-                std::mem::transmute::<
-                    DatabaseDownCasterSig<dyn Database>,
-                    ErasedDatabaseDownCasterSig,
-                >(|db| db)
-            },
-        });
+        view_casters.push(ViewCaster::new::<dyn Database>(|db| db));
         Self {
             source_type_id,
             view_casters,
@@ -83,17 +88,7 @@ impl Views {
         {
             return;
         }
-        self.view_casters.push(ViewCaster {
-            target_type_id,
-            type_name: std::any::type_name::<DbView>(),
-            // SAFETY: We are type erasing for storage, taking care of unerasing before we call
-            // the function pointer.
-            cast: unsafe {
-                std::mem::transmute::<DatabaseDownCasterSig<DbView>, ErasedDatabaseDownCasterSig>(
-                    func,
-                )
-            },
-        });
+        self.view_casters.push(ViewCaster::new::<DbView>(func));
     }
 
     /// Retrieve an downcaster function from `dyn Database` to `dyn DbView`.