thread group index to storage initializers

Author: nikomatsakis

components/salsa-macros/src/database_storage.rs

@@ -53,7 +53,7 @@ pub(crate) fn database(args: TokenStream, input: TokenStream) -> TokenStream {
         .zip(&query_group_names_snake)
         .zip(&query_group_storage_names)
         .zip(&query_group_key_names)
-        .zip(0_usize..)
+        .zip(0_u16..)
     {
         let group_path = &query_group.group_path;
         let group_name = query_group.name();

components/salsa-macros/src/query_group.rs

@@ -192,7 +192,7 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
     let mut query_descriptor_variants = proc_macro2::TokenStream::new();
     let mut group_data_elements = vec![];
     let mut storage_fields = proc_macro2::TokenStream::new();
-    let mut storage_defaults = proc_macro2::TokenStream::new();
+    let mut queries_with_storage = vec![];
     for query in &queries {
         let key_names: &Vec<_> = &(0..query.keys.len())
             .map(|i| Ident::new(&format!("key{}", i), Span::call_site()))
@@ -220,6 +220,8 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
             continue;
         }
 
+        queries_with_storage.push(fn_name);
+
         query_fn_definitions.extend(quote! {
             fn #fn_name(&self, #(#key_names: #keys),*) -> #value {
                 <Self as salsa::plumbing::GetQueryTable<#qt>>::get_query_table(self).get((#(#key_names),*))
@@ -295,7 +297,6 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
         storage_fields.extend(quote! {
             pub #fn_name: std::sync::Arc<<#qt as salsa::Query<DB__>>::Storage>,
         });
-        storage_defaults.extend(quote! { #fn_name: Default::default(), });
     }
 
     // Emit the trait itself.
@@ -349,7 +350,7 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
     });
 
     // Emit the query types.
-    for query in &queries {
+    for (query, query_index) in queries.iter().zip(0_u16..) {
         let fn_name = &query.fn_name;
         let qt = &query.query_type;
 
@@ -388,6 +389,8 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
                 type GroupStorage = #group_storage<#db>;
                 type GroupKey = #group_key;
 
+                const QUERY_INDEX: u16 = #query_index;
+
                 fn query_storage(
                     group_storage: &Self::GroupStorage,
                 ) -> &std::sync::Arc<Self::Storage> {
@@ -466,8 +469,6 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
     }
 
     // Emit query group storage struct
-    // It would derive Default, but then all database structs would have to implement Default
-    // as the derived version includes an unused `+ Default` constraint.
     output.extend(quote! {
         #trait_vis struct #group_storage<DB__>
         where
@@ -484,9 +485,12 @@ pub(crate) fn query_group(args: TokenStream, input: TokenStream) -> TokenStream
             DB__: salsa::plumbing::HasQueryGroup<#group_struct>,
             DB__: salsa::Database,
         {
-            #trait_vis fn new(group_index: usize) -> Self {
+            #trait_vis fn new(group_index: u16) -> Self {
                 #group_storage {
-                    #storage_defaults
+                    #(
+                        #queries_with_storage:
+                        std::sync::Arc::new(salsa::plumbing::QueryStorageOps::new(group_index)),
+                    )*
                 }
             }
         }

src/derived.rs

@@ -91,21 +91,6 @@ where
     }
 }
 
-impl<DB, Q, MP> Default for DerivedStorage<DB, Q, MP>
-where
-    Q: QueryFunction<DB>,
-    DB: Database + HasQueryGroup<Q::Group>,
-    MP: MemoizationPolicy<DB, Q>,
-{
-    fn default() -> Self {
-        DerivedStorage {
-            slot_map: RwLock::new(FxHashMap::default()),
-            lru_list: Default::default(),
-            policy: PhantomData,
-        }
-    }
-}
-
 impl<DB, Q, MP> DerivedStorage<DB, Q, MP>
 where
     Q: QueryFunction<DB>,
@@ -131,6 +116,14 @@ where
     DB: Database + HasQueryGroup<Q::Group>,
     MP: MemoizationPolicy<DB, Q>,
 {
+    fn new(_group_index: u16) -> Self {
+        DerivedStorage {
+            slot_map: RwLock::new(FxHashMap::default()),
+            lru_list: Default::default(),
+            policy: PhantomData,
+        }
+    }
+
     fn try_fetch(&self, db: &DB, key: &Q::Key) -> Result<Q::Value, CycleError<DB::DatabaseKey>> {
         let slot = self.slot(key);
         let StampedValue {

src/input.rs

@@ -47,18 +47,6 @@ where
 {
 }
 
-impl<DB, Q> Default for InputStorage<DB, Q>
-where
-    Q: Query<DB>,
-    DB: Database,
-{
-    fn default() -> Self {
-        InputStorage {
-            slots: Default::default(),
-        }
-    }
-}
-
 impl<DB, Q> InputStorage<DB, Q>
 where
     Q: Query<DB>,
@@ -74,6 +62,12 @@ where
     Q: Query<DB>,
     DB: Database,
 {
+    fn new(_group_index: u16) -> Self {
+        InputStorage {
+            slots: Default::default(),
+        }
+    }
+
     fn try_fetch(&self, db: &DB, key: &Q::Key) -> Result<Q::Value, CycleError<DB::DatabaseKey>> {
         let slot = self
             .slot(key)

src/interned.rs

@@ -128,42 +128,6 @@ where
 {
 }
 
-impl<DB, Q> Default for InternedStorage<DB, Q>
-where
-    Q: Query<DB>,
-    Q::Key: Eq + Hash,
-    Q::Value: InternKey,
-    DB: Database,
-{
-    fn default() -> Self {
-        InternedStorage {
-            tables: RwLock::new(InternTables::default()),
-        }
-    }
-}
-
-impl<DB, Q, IQ> Default for LookupInternedStorage<DB, Q, IQ>
-where
-    Q: Query<DB>,
-    Q::Key: InternKey,
-    Q::Value: Eq + Hash,
-    IQ: Query<
-        DB,
-        Key = Q::Value,
-        Value = Q::Key,
-        Group = Q::Group,
-        GroupStorage = Q::GroupStorage,
-        GroupKey = Q::GroupKey,
-    >,
-    DB: Database,
-{
-    fn default() -> Self {
-        LookupInternedStorage {
-            phantom: std::marker::PhantomData,
-        }
-    }
-}
-
 impl<K: Debug + Hash + Eq> InternTables<K> {
     /// Returns the slot for the given key.
     ///
@@ -320,6 +284,12 @@ where
     Q::Value: InternKey,
     DB: Database,
 {
+    fn new(_group_index: u16) -> Self {
+        InternedStorage {
+            tables: RwLock::new(InternTables::default()),
+        }
+    }
+
     fn try_fetch(&self, db: &DB, key: &Q::Key) -> Result<Q::Value, CycleError<DB::DatabaseKey>> {
         let slot = self.intern_index(db, key);
         let changed_at = slot.interned_at;
@@ -419,6 +389,12 @@ where
     >,
     DB: Database + HasQueryGroup<Q::Group>,
 {
+    fn new(_group_index: u16) -> Self {
+        LookupInternedStorage {
+            phantom: std::marker::PhantomData,
+        }
+    }
+
     fn try_fetch(&self, db: &DB, key: &Q::Key) -> Result<Q::Value, CycleError<DB::DatabaseKey>> {
         let index = key.as_intern_id();
         let group_storage = <DB as HasQueryGroup<Q::Group>>::group_storage(db);

src/lib.rs

@@ -441,6 +441,9 @@ pub unsafe trait Query<DB: Database>: Debug + Default + Sized + 'static {
     /// Type that identifies a particular query within the group + its key.
     type GroupKey;
 
+    /// A unique index identifying this query within the group.
+    const QUERY_INDEX: u16;
+
     /// Extact storage for this query from the storage for its group.
     fn query_storage(group_storage: &Self::GroupStorage) -> &Arc<Self::Storage>;
 

src/plumbing.rs

@@ -142,12 +142,14 @@ where
     fn database_key(group_key: G::GroupKey) -> Self::DatabaseKey;
 }
 
-pub trait QueryStorageOps<DB, Q>: Default
+pub trait QueryStorageOps<DB, Q>
 where
     Self: QueryStorageMassOps<DB>,
     DB: Database,
     Q: Query<DB>,
 {
+    fn new(group_index: u16) -> Self;
+
     /// Execute the query, returning the result (often, the result
     /// will be memoized).  This is the "main method" for
     /// queries.
@@ -169,7 +171,7 @@ where
 /// An optional trait that is implemented for "user mutable" storage:
 /// that is, storage whose value is not derived from other storage but
 /// is set independently.
-pub trait InputQueryStorageOps<DB, Q>: Default
+pub trait InputQueryStorageOps<DB, Q>
 where
     DB: Database,
     Q: Query<DB>,
@@ -187,11 +189,11 @@ where
 /// An optional trait that is implemented for "user mutable" storage:
 /// that is, storage whose value is not derived from other storage but
 /// is set independently.
-pub trait LruQueryStorageOps: Default {
+pub trait LruQueryStorageOps {
     fn set_lru_capacity(&self, new_capacity: usize);
 }
 
-pub trait DerivedQueryStorageOps<DB, Q>: Default
+pub trait DerivedQueryStorageOps<DB, Q>
 where
     DB: Database,
     Q: Query<DB>,