Drop clone requirement for accumulated values

Author: Veykril

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

@@ -277,7 +277,7 @@ macro_rules! setup_tracked_fn {
                 pub fn accumulated<$db_lt, A: salsa::Accumulator>(
                     $db: &$db_lt dyn $Db,
                     $($input_id: $input_ty,)*
-                ) -> Vec<A> {
+                ) -> Vec<&$db_lt A> {
                     use salsa::plumbing as $zalsa;
                     let key = $zalsa::macro_if! {
                         if $needs_interner {

src/accumulator.rs

@@ -24,7 +24,7 @@ pub(crate) mod accumulated_map;
 
 /// Trait implemented on the struct that user annotated with `#[salsa::accumulator]`.
 /// The `Self` type is therefore the types to be accumulated.
-pub trait Accumulator: Clone + Debug + Send + Sync + Any + Sized + UnwindSafe {
+pub trait Accumulator: Debug + Send + Sync + Any + Sized + UnwindSafe {
     const DEBUG_NAME: &'static str;
 
     /// Accumulate an instance of this in the database for later retrieval.

src/accumulator/accumulated.rs

@@ -11,16 +11,15 @@ pub(crate) struct Accumulated<A: Accumulator> {
 pub(crate) trait AnyAccumulated: Any + Debug + Send + Sync {
     fn as_dyn_any(&self) -> &dyn Any;
     fn as_dyn_any_mut(&mut self) -> &mut dyn Any;
-    fn cloned(&self) -> Box<dyn AnyAccumulated>;
 }
 
 impl<A: Accumulator> Accumulated<A> {
     pub fn push(&mut self, value: A) {
         self.values.push(value);
     }
 
-    pub fn extend_with_accumulated(&self, values: &mut Vec<A>) {
-        values.extend_from_slice(&self.values);
+    pub fn extend_with_accumulated<'slf>(&'slf self, values: &mut Vec<&'slf A>) {
+        values.extend(&self.values);
     }
 }
 
@@ -43,11 +42,6 @@ where
     fn as_dyn_any_mut(&mut self) -> &mut dyn Any {
         self
     }
-
-    fn cloned(&self) -> Box<dyn AnyAccumulated> {
-        let this: Self = self.clone();
-        Box::new(this)
-    }
 }
 
 impl dyn AnyAccumulated {

src/accumulator/accumulated_map.rs

@@ -22,10 +22,10 @@ impl AccumulatedMap {
             .accumulate(value);
     }
 
-    pub fn extend_with_accumulated<A: Accumulator>(
-        &self,
+    pub fn extend_with_accumulated<'slf, A: Accumulator>(
+        &'slf self,
         index: IngredientIndex,
-        output: &mut Vec<A>,
+        output: &mut Vec<&'slf A>,
     ) {
         let Some(a) = self.map.get(&index) else {
             return;
@@ -42,18 +42,6 @@ impl AccumulatedMap {
     }
 }
 
-impl Clone for AccumulatedMap {
-    fn clone(&self) -> Self {
-        Self {
-            map: self
-                .map
-                .iter()
-                .map(|(&key, value)| (key, value.cloned()))
-                .collect(),
-        }
-    }
-}
-
 /// Tracks whether any input read during a query's execution has any accumulated values.
 ///
 /// Knowning whether any input has accumulated values makes aggregating the accumulated values

src/function/accumulated.rs

@@ -14,7 +14,7 @@ where
 {
     /// Helper used by `accumulate` functions. Computes the results accumulated by `database_key_index`
     /// and its inputs.
-    pub fn accumulated_by<A>(&self, db: &C::DbView, key: Id) -> Vec<A>
+    pub fn accumulated_by<'db, A>(&self, db: &'db C::DbView, key: Id) -> Vec<&'db A>
     where
         A: accumulator::Accumulator,
     {