cycle_panic

cycle_panic.rs

#![allow(warnings)]

use std::panic::{RefUnwindSafe, UnwindSafe};

use expect_test::expect;
use salsa::Durability;
use test_log::test;


#[derive(PartialEq, Eq, Hash, Clone, Debug)]
struct Error {
    cycle: Vec<String>,
}

#[salsa::jar(db = Db)]
struct Jar(
    MyInput,
    MyTracked,
    memoized,
    memoized_a,
    memoized_b,
);

trait Db: salsa::DbWithJar<Jar> {}

#[salsa::db(Jar)]
#[derive(Default)]
struct Database {
    storage: salsa::Storage<Self>,
}

impl Db for Database {}

impl salsa::Database for Database {}

impl RefUnwindSafe for Database {}

#[salsa::input(jar = Jar)]
struct MyInput {
    field: u32,
}

#[salsa::tracked(jar = Jar)]
struct MyTracked {
    field: u32,
}

#[salsa::tracked(jar = Jar)]
fn memoized(db: &dyn Db, input: MyInput) -> u32 {
    memoized_a(db, MyTracked::new(db, input.field(db)))
}

#[salsa::tracked(jar = Jar)]
fn memoized_a(db: &dyn Db, tracked: MyTracked) -> u32 {
    MyTracked::new(db, 0);
    return memoized_b(db, tracked);
}

fn recovery_fn(db: &dyn Db, cycle: &salsa::Cycle, input: MyTracked) -> u32 {
    0
}

#[salsa::tracked(jar = Jar, recovery_fn=recovery_fn)]
fn memoized_b(db: &dyn Db, tracked: MyTracked) -> u32 {
    tracked.field(db) + memoized_a(db, tracked)
}

#[test]
fn cycle_memoized() {
    let mut db = Database::default();
    let input = MyInput::new(&db, 2);
    let v = memoized(&db, input);
    input.set_field(&mut db).to(3);
    let v = memoized(&db, input);
}