Use Result over catch_unwind for cancellation and cycle handling

Cargo.toml

@@ -11,6 +11,7 @@ description = "A generic framework for on-demand, incrementalized computation (e
 arc-swap = "1"
 crossbeam = "0.8"
 dashmap = "6"
+drop_bomb = "0.1.5"
 hashlink = "0.9"
 indexmap = "2"
 append-only-vec = "0.1.5"

benches/compare.rs

@@ -7,8 +7,8 @@ pub struct Input {
 }
 
 #[salsa::tracked]
-pub fn length(db: &dyn salsa::Database, input: Input) -> usize {
- input.text(db).len()
+pub fn length(db: &dyn salsa::Database, input: Input) -> salsa::Result<usize> {
+ Ok(input.text(db)?.len())
 }
 
 #[salsa::interned]
@@ -17,8 +17,11 @@ pub struct InternedInput<'db> {
 }
 
 #[salsa::tracked]
-pub fn interned_length<'db>(db: &'db dyn salsa::Database, input: InternedInput<'db>) -> usize {
- input.text(db).len()
+pub fn interned_length<'db>(
+ db: &'db dyn salsa::Database,
+ input: InternedInput<'db>,
+) -> salsa::Result<usize> {
+ Ok(input.text(db).len())
 }
 
 fn mutating_inputs(c: &mut Criterion) {
@@ -38,11 +41,11 @@ fn mutating_inputs(c: &mut Criterion) {
  group.bench_function(BenchmarkId::new("mutating", n), |b| {
  b.iter(|| {
  let input = Input::new(&db, base_string.clone());
- let actual_len = length(&db, input);
+ let actual_len = length(&db, input).unwrap();
  assert_eq!(base_len, actual_len);
 
  input.set_text(&mut db).to(string.clone());
- let actual_len = length(&db, input);
+ let actual_len = length(&db, input).unwrap();
  assert_eq!(new_len, actual_len);
  })
  });
@@ -60,30 +63,30 @@ fn inputs(c: &mut Criterion) {
 
  group.bench_function(BenchmarkId::new("new", "InternedInput"), |b| {
  b.iter(|| {
- let input: InternedInput = InternedInput::new(&db, "hello, world!".to_owned());
- interned_length(&db, input);
+ let input: InternedInput = InternedInput::new(&db, "hello, world!".to_owned()).unwrap();
+ interned_length(&db, input).unwrap();
  })
  });
 
  group.bench_function(BenchmarkId::new("amortized", "InternedInput"), |b| {
- let input = InternedInput::new(&db, "hello, world!".to_owned());
- let _ = interned_length(&db, input);
+ let input = InternedInput::new(&db, "hello, world!".to_owned()).unwrap();
+ let _ = interned_length(&db, input).unwrap();
 
- b.iter(|| interned_length(&db, input));
+ b.iter(|| interned_length(&db, input).unwrap());
  });
 
  group.bench_function(BenchmarkId::new("new", "Input"), |b| {
  b.iter(|| {
  let input = Input::new(&db, "hello, world!".to_owned());
- length(&db, input);
+ length(&db, input).unwrap();
  })
  });
 
  group.bench_function(BenchmarkId::new("amortized", "Input"), |b| {
  let input = Input::new(&db, "hello, world!".to_owned());
- let _ = length(&db, input);
+ let _ = length(&db, input).unwrap();
 
- b.iter(|| length(&db, input));
+ b.iter(|| length(&db, input).unwrap());
  });
 
  group.finish();

benches/incremental.rs

@@ -12,14 +12,14 @@ struct Tracked<'db> {
 }
 
 #[salsa::tracked(return_ref)]
-fn index<'db>(db: &'db dyn salsa::Database, input: Input) -> Vec<Tracked<'db>> {
- (0..input.field(db)).map(|i| Tracked::new(db, i)).collect()
+fn index<'db>(db: &'db dyn salsa::Database, input: Input) -> salsa::Result<Vec<Tracked<'db>>> {
+ (0..input.field(db)?).map(|i| Tracked::new(db, i)).collect()
 }
 
 #[salsa::tracked]
-fn root(db: &dyn salsa::Database, input: Input) -> usize {
- let index = index(db, input);
- index.len()
+fn root(db: &dyn salsa::Database, input: Input) -> salsa::Result<usize> {
+ let index = index(db, input)?;
+ Ok(index.len())
 }
 
 fn many_tracked_structs(criterion: &mut Criterion) {
@@ -41,7 +41,7 @@ fn many_tracked_structs(criterion: &mut Criterion) {
  // Make a change, but fetch the result for the other input
  input2.set_field(db).to(2);
 
- let result = root(db, *input);
+ let result = root(db, *input).unwrap();
 
  assert_eq!(result, 1_000);
  },

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

@@ -142,7 +142,7 @@ macro_rules! setup_input_struct {
  }
 
  $(
- $field_getter_vis fn $field_getter_id<'db, $Db>(self, db: &'db $Db) -> $zalsa::maybe_cloned_ty!($field_option, 'db, $field_ty)
+ $field_getter_vis fn $field_getter_id<'db, $Db>(self, db: &'db $Db) -> salsa::Result<$zalsa::maybe_cloned_ty!($field_option, 'db, $field_ty)>
  where
  // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
  $Db: ?Sized + $zalsa::Database,
@@ -151,12 +151,12 @@ macro_rules! setup_input_struct {
  db.as_dyn_database(),
  self,
  $field_index,
- );
- $zalsa::maybe_clone!(
+ )?;
+ Ok($zalsa::maybe_clone!(
  $field_option,
  $field_ty,
  &fields.$field_index,
- )
+ ))
  }
  )*
 

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

@@ -126,7 +126,7 @@ macro_rules! setup_interned_struct {
  }
 
  impl<$db_lt> $Struct<$db_lt> {
- pub fn $new_fn<$Db>(db: &$db_lt $Db, $($field_id: $field_ty),*) -> Self
+ pub fn $new_fn<$Db>(db: &$db_lt $Db, $($field_id: $field_ty),*) -> salsa::Result<Self>
  where
  // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
  $Db: ?Sized + salsa::Database,

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

@@ -80,7 +80,7 @@ macro_rules! setup_tracked_fn {
  $($input_id: $input_ty,)*
  ) -> salsa::plumbing::macro_if! {
  if $return_ref {
- &$db_lt $output_ty
+ salsa::Result<&$db_lt <$output_ty as salsa::plumbing::HasOutput>::Output>
  } else {
  $output_ty
  }
@@ -156,7 +156,7 @@ macro_rules! setup_tracked_fn {
 
  type Input<$db_lt> = ($($input_ty),*);
 
- type Output<$db_lt> = $output_ty;
+ type Output<$db_lt> = <$output_ty as $zalsa::HasOutput>::Output;
 
  const CYCLE_STRATEGY: $zalsa::CycleRecoveryStrategy = $zalsa::CycleRecoveryStrategy::$cycle_recovery_strategy;
 
@@ -173,7 +173,7 @@ macro_rules! setup_tracked_fn {
  }
  }
 
- fn execute<$db_lt>($db: &$db_lt Self::DbView, ($($input_id),*): ($($input_ty),*)) -> Self::Output<$db_lt> {
+ fn execute<$db_lt>($db: &$db_lt Self::DbView, ($($input_id),*): ($($input_ty),*)) -> salsa::Result<Self::Output<$db_lt>> {
  $inner_fn
 
  $inner($db, $($input_id),*)
@@ -183,7 +183,7 @@ macro_rules! setup_tracked_fn {
  db: &$db_lt dyn $Db,
  cycle: &$zalsa::Cycle,
  ($($input_id),*): ($($input_ty),*)
- ) -> Self::Output<$db_lt> {
+ ) -> salsa::Result<Self::Output<$db_lt>> {
  $($cycle_recovery_fn)*(db, cycle, $($input_id),*)
  }
 
@@ -231,11 +231,11 @@ macro_rules! setup_tracked_fn {
  pub fn accumulated<$db_lt, A: salsa::Accumulator>(
  $db: &$db_lt dyn $Db,
  $($input_id: $input_ty,)*
- ) -> Vec<A> {
+ ) -> salsa::Result<Vec<A>> {
  use salsa::plumbing as $zalsa;
  let key = $zalsa::macro_if! {
  if $needs_interner {
- $Configuration::intern_ingredient($db).intern_id($db.as_dyn_database(), ($($input_id),*))
+ $Configuration::intern_ingredient($db).intern_id($db.as_dyn_database(), ($($input_id),*))?
  } else {
  $zalsa::AsId::as_id(&($($input_id),*))
  }
@@ -248,7 +248,7 @@ macro_rules! setup_tracked_fn {
  pub fn specify<$db_lt>(
  $db: &$db_lt dyn $Db,
  $($input_id: $input_ty,)*
- value: $output_ty,
+ value: <$Configuration as $zalsa::function::Configuration>::Output<$db_lt>,
  ) {
  let key = $zalsa::AsId::as_id(&($($input_id),*));
  $Configuration::fn_ingredient($db).specify_and_record(
@@ -271,21 +271,21 @@ macro_rules! setup_tracked_fn {
  let result = $zalsa::macro_if! {
  if $needs_interner {
  {
- let key = $Configuration::intern_ingredient($db).intern_id($db.as_dyn_database(), ($($input_id),*));
- $Configuration::fn_ingredient($db).fetch($db, key)
+ let key = $Configuration::intern_ingredient($db).intern_id($db.as_dyn_database(), ($($input_id),*))?;
+ $Configuration::fn_ingredient($db).fetch($db, key)?
  }
  } else {
- $Configuration::fn_ingredient($db).fetch($db, $zalsa::AsId::as_id(&($($input_id),*)))
+ $Configuration::fn_ingredient($db).fetch($db, $zalsa::AsId::as_id(&($($input_id),*)))?
  }
  };
 
- $zalsa::macro_if! {
+ Ok($zalsa::macro_if! {
  if $return_ref {
  result
  } else {
- <$output_ty as std::clone::Clone>::clone(result)
+ <<$Configuration as $zalsa::function::Configuration>::Output<$db_lt> as std::clone::Clone>::clone(result)
  }
- }
+ })
  })
  }
  };

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

@@ -184,7 +184,7 @@ macro_rules! setup_tracked_struct {
  }
 
  impl<$db_lt> $Struct<$db_lt> {
- pub fn $new_fn<$Db>(db: &$db_lt $Db, $($field_id: $field_ty),*) -> Self
+ pub fn $new_fn<$Db>(db: &$db_lt $Db, $($field_id: $field_ty),*) -> salsa::Result<Self>
  where
  // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
  $Db: ?Sized + $zalsa::Database,
@@ -196,18 +196,18 @@ macro_rules! setup_tracked_struct {
  }
 
  $(
- $field_getter_vis fn $field_getter_id<$Db>(self, db: &$db_lt $Db) -> $crate::maybe_cloned_ty!($field_option, $db_lt, $field_ty)
+ $field_getter_vis fn $field_getter_id<$Db>(self, db: &$db_lt $Db) -> salsa::Result<$crate::maybe_cloned_ty!($field_option, $db_lt, $field_ty)>
  where
  // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
  $Db: ?Sized + $zalsa::Database,
  {
  let db = db.as_dyn_database();
- let fields = $Configuration::ingredient(db).field(db, self, $field_index);
- $crate::maybe_clone!(
+ let fields = $Configuration::ingredient(db).field(db, self, $field_index)?;
+ Ok($crate::maybe_clone!(
  $field_option,
  $field_ty,
  &fields.$field_index,
- )
+ ))
  }
  )*
 

components/salsa-macros/src/tracked_impl.rs

@@ -274,7 +274,8 @@ impl Macro {
  ) -> syn::Result<()> {
  if let Some(return_ref) = &args.return_ref {
  if let syn::ReturnType::Type(_, t) = &mut sig.output {
- **t = parse_quote!(& #db_lt #t)
+ **t =
+ parse_quote!(salsa::Result<&#db_lt <#t as salsa::plumbing::HasOutput>::Output>)
  } else {
  return Err(syn::Error::new_spanned(
  return_ref,

examples/calc/compile.rs

@@ -1,7 +1,9 @@
 use crate::{ir::SourceProgram, parser::parse_statements, type_check::type_check_program};
 
 #[salsa::tracked]
-pub fn compile(db: &dyn crate::Db, source_program: SourceProgram) {
- let program = parse_statements(db, source_program);
- type_check_program(db, program);
+pub fn compile(db: &dyn crate::Db, source_program: SourceProgram) -> salsa::Result<()> {
+ let program = parse_statements(db, source_program)?;
+ type_check_program(db, program)?;
+
+ Ok(())
 }

examples/calc/ir.rs

@@ -108,18 +108,18 @@ pub struct Diagnostic {
 
 impl Diagnostic {
  #[cfg(test)]
- pub fn render(&self, db: &dyn crate::Db, src: SourceProgram) -> String {
+ pub fn render(&self, db: &dyn crate::Db, src: SourceProgram) -> salsa::Result<String> {
  use annotate_snippets::*;
- let line_start = src.text(db)[..self.start].lines().count() + 1;
- Renderer::plain()
+ let line_start = src.text(db)?[..self.start].lines().count() + 1;
+ Ok(Renderer::plain()
  .render(
  Level::Error.title(&self.message).snippet(
- Snippet::source(src.text(db))
+ Snippet::source(src.text(db)?)
  .line_start(line_start)
  .origin("input")
  .annotation(Level::Error.span(self.start..self.end).label("here")),
  ),
  )
- .to_string()
+ .to_string())
  }
 }

examples/calc/main.rs

@@ -11,7 +11,7 @@ mod type_check;
 pub fn main() {
  let db: CalcDatabaseImpl = Default::default();
  let source_program = SourceProgram::new(&db, String::new());
- compile::compile(&db, source_program);
- let diagnostics = compile::compile::accumulated::<Diagnostic>(&db, source_program);
+ compile::compile(&db, source_program).unwrap();
+ let diagnostics = compile::compile::accumulated::<Diagnostic>(&db, source_program).unwrap();
  eprintln!("{diagnostics:?}");
 }