[RFC] fixpoint iteration support

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

@@ -37,6 +37,9 @@ macro_rules! setup_tracked_fn {
         // Path to the cycle recovery function to use.
         cycle_recovery_fn: ($($cycle_recovery_fn:tt)*),
 
+        // Path to function to get the initial value to use for cycle recovery.
+        cycle_recovery_initial: ($($cycle_recovery_initial:tt)*),
+
         // Name of cycle recovery strategy variant to use.
         cycle_recovery_strategy: $cycle_recovery_strategy:ident,
 
@@ -155,15 +158,15 @@ macro_rules! setup_tracked_fn {
 
                 const CYCLE_STRATEGY: $zalsa::CycleRecoveryStrategy = $zalsa::CycleRecoveryStrategy::$cycle_recovery_strategy;
 
-                fn should_backdate_value(
+                fn values_equal(
                     old_value: &Self::Output<'_>,
                     new_value: &Self::Output<'_>,
                 ) -> bool {
                     $zalsa::macro_if! {
                         if $no_eq {
                             false
                         } else {
-                            $zalsa::should_backdate_value(old_value, new_value)
+                            $zalsa::values_equal(old_value, new_value)
                         }
                     }
                 }
@@ -174,12 +177,17 @@ macro_rules! setup_tracked_fn {
                     $inner($db, $($input_id),*)
                 }
 
+                fn cycle_initial<$db_lt>(db: &$db_lt dyn $Db, ($($input_id),*): ($($input_ty),*)) -> Self::Output<$db_lt> {
+                    $($cycle_recovery_initial)*(db, $($input_id),*)
+                }
+
                 fn recover_from_cycle<$db_lt>(
                     db: &$db_lt dyn $Db,
-                    cycle: &$zalsa::Cycle,
+                    value: &Self::Output<$db_lt>,
+                    count: u32,
                     ($($input_id),*): ($($input_ty),*)
-                ) -> Self::Output<$db_lt> {
-                    $($cycle_recovery_fn)*(db, cycle, $($input_id),*)
+                ) -> $zalsa::CycleRecoveryAction<Self::Output<$db_lt>> {
+                    $($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> {

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

@@ -3,11 +3,18 @@
 // a macro because it can take a variadic number of arguments.
 #[macro_export]
 macro_rules! unexpected_cycle_recovery {
-    ($db:ident, $cycle:ident, $($other_inputs:ident),*) => {
-        {
-            std::mem::drop($db);
-            std::mem::drop(($($other_inputs),*));
-            panic!("cannot recover from cycle `{:?}`", $cycle)
-        }
-    }
+    ($db:ident, $value:ident, $count:ident, $($other_inputs:ident),*) => {{
+        std::mem::drop($db);
+        std::mem::drop(($($other_inputs),*));
+        panic!("cannot recover from cycle")
+    }};
+}
+
+#[macro_export]
+macro_rules! unexpected_cycle_initial {
+    ($db:ident, $($other_inputs:ident),*) => {{
+        std::mem::drop($db);
+        std::mem::drop(($($other_inputs),*));
+        panic!("no cycle initial value")
+    }};
 }

components/salsa-macros/src/accumulator.rs

@@ -39,7 +39,8 @@ impl AllowedOptions for Accumulator {
     const SINGLETON: bool = false;
     const DATA: bool = false;
     const DB: bool = false;
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+    const CYCLE_INITIAL: bool = false;
     const LRU: bool = false;
     const CONSTRUCTOR_NAME: bool = false;
 }

components/salsa-macros/src/input.rs

@@ -50,7 +50,9 @@ impl crate::options::AllowedOptions for InputStruct {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+
+    const CYCLE_INITIAL: bool = false;
 
     const LRU: bool = false;
 

components/salsa-macros/src/interned.rs

@@ -51,7 +51,9 @@ impl crate::options::AllowedOptions for InternedStruct {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+
+    const CYCLE_INITIAL: bool = false;
 
     const LRU: bool = false;
 

components/salsa-macros/src/options.rs

@@ -44,10 +44,15 @@ pub(crate) struct Options<A: AllowedOptions> {
     /// If this is `Some`, the value is the `<path>`.
     pub db_path: Option<syn::Path>,
 
-    /// The `recovery_fn = <path>` option is used to indicate the recovery function.
+    /// The `cycle_fn = <path>` option is used to indicate the cycle recovery function.
     ///
     /// If this is `Some`, the value is the `<path>`.
-    pub recovery_fn: Option<syn::Path>,
+    pub cycle_fn: Option<syn::Path>,
+
+    /// The `cycle_initial = <path>` option is the initial value for cycle iteration.
+    ///
+    /// If this is `Some`, the value is the `<path>`.
+    pub cycle_initial: Option<syn::Path>,
 
     /// The `data = <ident>` option is used to define the name of the data type for an interned
     /// struct.
@@ -79,7 +84,8 @@ impl<A: AllowedOptions> Default for Options<A> {
             no_debug: Default::default(),
             no_clone: Default::default(),
             db_path: Default::default(),
-            recovery_fn: Default::default(),
+            cycle_fn: Default::default(),
+            cycle_initial: Default::default(),
             data: Default::default(),
             constructor_name: Default::default(),
             phantom: Default::default(),
@@ -99,7 +105,8 @@ pub(crate) trait AllowedOptions {
     const SINGLETON: bool;
     const DATA: bool;
     const DB: bool;
-    const RECOVERY_FN: bool;
+    const CYCLE_FN: bool;
+    const CYCLE_INITIAL: bool;
     const LRU: bool;
     const CONSTRUCTOR_NAME: bool;
 }
@@ -207,20 +214,39 @@ impl<A: AllowedOptions> syn::parse::Parse for Options<A> {
                         "`db` option not allowed here",
                     ));
                 }
-            } else if ident == "recovery_fn" {
-                if A::RECOVERY_FN {
+            } else if ident == "cycle_fn" {
+                if A::CYCLE_FN {
+                    let _eq = Equals::parse(input)?;
+                    let path = syn::Path::parse(input)?;
+                    if let Some(old) = std::mem::replace(&mut options.cycle_fn, Some(path)) {
+                        return Err(syn::Error::new(
+                            old.span(),
+                            "option `cycle_fn` provided twice",
+                        ));
+                    }
+                } else {
+                    return Err(syn::Error::new(
+                        ident.span(),
+                        "`cycle_fn` option not allowed here",
+                    ));
+                }
+            } else if ident == "cycle_initial" {
+                if A::CYCLE_INITIAL {
+                    // TODO(carljm) should it be an error to give cycle_initial without cycle_fn,
+                    // or should we just allow this to fall into potentially infinite iteration, if
+                    // iteration never converges?
                     let _eq = Equals::parse(input)?;
                     let path = syn::Path::parse(input)?;
-                    if let Some(old) = std::mem::replace(&mut options.recovery_fn, Some(path)) {
+                    if let Some(old) = std::mem::replace(&mut options.cycle_initial, Some(path)) {
                         return Err(syn::Error::new(
                             old.span(),
-                            "option `recovery_fn` provided twice",
+                            "option `cycle_initial` provided twice",
                         ));
                     }
                 } else {
                     return Err(syn::Error::new(
                         ident.span(),
-                        "`recovery_fn` option not allowed here",
+                        "`cycle_initial` option not allowed here",
                     ));
                 }
             } else if ident == "data" {

components/salsa-macros/src/tracked_fn.rs

@@ -39,7 +39,9 @@ impl crate::options::AllowedOptions for TrackedFn {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = true;
+    const CYCLE_FN: bool = true;
+
+    const CYCLE_INITIAL: bool = true;
 
     const LRU: bool = true;
 
@@ -68,9 +70,20 @@ impl Macro {
         let input_ids = self.input_ids(&item);
         let input_tys = self.input_tys(&item)?;
         let output_ty = self.output_ty(&db_lt, &item)?;
-        let (cycle_recovery_fn, cycle_recovery_strategy) = self.cycle_recovery();
+        let (cycle_recovery_fn, cycle_recovery_initial, cycle_recovery_strategy) =
+            self.cycle_recovery()?;
         let is_specifiable = self.args.specify.is_some();
-        let no_eq = self.args.no_eq.is_some();
+        let no_eq = if let Some(token) = &self.args.no_eq {
+            if self.args.cycle_fn.is_some() {
+                return Err(syn::Error::new_spanned(
+                    token,
+                    "the `no_eq` option cannot be used with `cycle_fn`",
+                ));
+            }
+            true
+        } else {
+            false
+        };
 
         let mut inner_fn = item.clone();
         inner_fn.vis = syn::Visibility::Inherited;
@@ -127,6 +140,7 @@ impl Macro {
                 output_ty: #output_ty,
                 inner_fn: #inner_fn,
                 cycle_recovery_fn: #cycle_recovery_fn,
+                cycle_recovery_initial: #cycle_recovery_initial,
                 cycle_recovery_strategy: #cycle_recovery_strategy,
                 is_specifiable: #is_specifiable,
                 no_eq: #no_eq,
@@ -160,14 +174,28 @@ impl Macro {
 
         Ok(ValidFn { db_ident, db_path })
     }
-    fn cycle_recovery(&self) -> (TokenStream, TokenStream) {
-        if let Some(recovery_fn) = &self.args.recovery_fn {
-            (quote!((#recovery_fn)), quote!(Fallback))
-        } else {
-            (
+    fn cycle_recovery(&self) -> syn::Result<(TokenStream, TokenStream, TokenStream)> {
+        // TODO should we ask the user to specify a struct that impls a trait with two methods,
+        // rather than asking for two methods separately?
+        match (&self.args.cycle_fn, &self.args.cycle_initial) {
+            (Some(cycle_fn), Some(cycle_initial)) => Ok((
+                quote!((#cycle_fn)),
+                quote!((#cycle_initial)),
+                quote!(Fixpoint),
+            )),
+            (None, None) => Ok((
                 quote!((salsa::plumbing::unexpected_cycle_recovery!)),
+                quote!((salsa::plumbing::unexpected_cycle_initial!)),
                 quote!(Panic),
-            )
+            )),
+            (Some(_), None) => Err(syn::Error::new_spanned(
+                self.args.cycle_fn.as_ref().unwrap(),
+                "must provide `cycle_initial` along with `cycle_fn`",
+            )),
+            (None, Some(_)) => Err(syn::Error::new_spanned(
+                self.args.cycle_initial.as_ref().unwrap(),
+                "must provide `cycle_fn` along with `cycle_initial`",
+            )),
         }
     }
 

components/salsa-macros/src/tracked_struct.rs

@@ -45,7 +45,9 @@ impl crate::options::AllowedOptions for TrackedStruct {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+
+    const CYCLE_INITIAL: bool = false;
 
     const LRU: bool = false;
 

src/accumulator.rs

@@ -12,6 +12,7 @@ use accumulated_map::AccumulatedMap;
 
 use crate::{
     cycle::CycleRecoveryStrategy,
+    function::VerifyResult,
     ingredient::{fmt_index, Ingredient, Jar},
     plumbing::JarAux,
     zalsa::IngredientIndex,
@@ -102,10 +103,14 @@ impl<A: Accumulator> Ingredient for IngredientImpl<A> {
         _db: &dyn Database,
         _input: Option<Id>,
         _revision: Revision,
-    ) -> bool {
+    ) -> VerifyResult {
         panic!("nothing should ever depend on an accumulator directly")
     }
 
+    fn is_verified_final<'db>(&'db self, _db: &'db dyn Database, _input: Id) -> bool {
+        false
+    }
+
     fn cycle_recovery_strategy(&self) -> CycleRecoveryStrategy {
         CycleRecoveryStrategy::Panic
     }