Bump the edition to 2024

Cargo.toml

@@ -113,7 +113,7 @@ members = ["components/salsa-macro-rules", "components/salsa-macros"]
 
 [workspace.package]
 authors = ["Salsa developers"]
-edition = "2021"
+edition = "2024"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/salsa-rs/salsa"
 rust-version = "1.85"

benches/accumulator.rs

@@ -1,6 +1,6 @@
 use std::hint::black_box;
 
-use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Criterion};
+use codspeed_criterion_compat::{BatchSize, Criterion, criterion_group, criterion_main};
 use salsa::Accumulator;
 
 #[salsa::input]

benches/compare.rs

@@ -2,7 +2,7 @@ use std::hint::black_box;
 use std::mem::transmute;
 
 use codspeed_criterion_compat::{
-    criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion,
+    BatchSize, BenchmarkId, Criterion, criterion_group, criterion_main,
 };
 use salsa::Setter;
 

benches/dataflow.rs

@@ -5,7 +5,7 @@
 use std::collections::BTreeSet;
 use std::iter::IntoIterator;
 
-use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Criterion};
+use codspeed_criterion_compat::{BatchSize, Criterion, criterion_group, criterion_main};
 use salsa::{Database as Db, Setter};
 
 /// A Use of a symbol.

benches/incremental.rs

@@ -1,6 +1,6 @@
 use std::hint::black_box;
 
-use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Criterion};
+use codspeed_criterion_compat::{BatchSize, Criterion, criterion_group, criterion_main};
 use salsa::Setter;
 
 #[salsa::input]

components/salsa-macros/src/tracked.rs

@@ -1,5 +1,5 @@
-use syn::spanned::Spanned;
 use syn::Item;
+use syn::spanned::Spanned;
 
 use crate::token_stream_with_error;
 

components/salsa-macros/src/tracked_fn.rs

@@ -148,7 +148,7 @@ impl Macro {
                     return Err(syn::Error::new_spanned(
                         self.args.specify.as_ref().unwrap(),
                         "only functions with a single salsa struct as their input can be specified",
-                    ))
+                    ));
                 }
                 FunctionType::SalsaStruct => {}
             }

components/salsa-macros/src/update.rs

@@ -1,5 +1,5 @@
 use proc_macro2::{Literal, Span, TokenStream};
-use syn::{parenthesized, parse::ParseStream, spanned::Spanned, Token};
+use syn::{Token, parenthesized, parse::ParseStream, spanned::Spanned};
 use synstructure::BindStyle;
 
 use crate::{hygiene::Hygiene, kw};

examples/calc/parser.rs

@@ -69,11 +69,12 @@ impl<'db> Parser<'_, 'db> {
     // Invoke `f` and, if it returns `None`, then restore the parsing position.
     fn probe<T: std::fmt::Debug>(&mut self, f: impl FnOnce(&mut Self) -> Option<T>) -> Option<T> {
         let p = self.position;
-        if let Some(v) = f(self) {
-            Some(v)
-        } else {
-            self.position = p;
-            None
+        match f(self) {
+            Some(v) => Some(v),
+            _ => {
+                self.position = p;
+                None
+            }
         }
     }
 
@@ -307,11 +308,7 @@ impl<'db> Parser<'_, 'db> {
             self.consume(ch);
         }
 
-        if s.is_empty() {
-            None
-        } else {
-            Some(s)
-        }
+        if s.is_empty() { None } else { Some(s) }
     }
 
     /// Parses a number.

examples/lazy-input/main.rs

@@ -4,12 +4,12 @@ use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use crossbeam_channel::{unbounded, Sender};
-use dashmap::mapref::entry::Entry;
+use crossbeam_channel::{Sender, unbounded};
 use dashmap::DashMap;
-use eyre::{eyre, Context, Report, Result};
+use dashmap::mapref::entry::Entry;
+use eyre::{Context, Report, Result, eyre};
 use notify_debouncer_mini::notify::{RecommendedWatcher, RecursiveMode};
-use notify_debouncer_mini::{new_debouncer, DebounceEventResult, Debouncer};
+use notify_debouncer_mini::{DebounceEventResult, Debouncer, new_debouncer};
 use salsa::{Accumulator, Setter, Storage};
 
 // ANCHOR: main

src/accumulator/accumulated_map.rs

@@ -2,10 +2,10 @@ use std::ops;
 
 use rustc_hash::FxBuildHasher;
 
+use crate::IngredientIndex;
 use crate::accumulator::accumulated::Accumulated;
 use crate::accumulator::{Accumulator, AnyAccumulated};
 use crate::sync::atomic::{AtomicBool, Ordering};
-use crate::IngredientIndex;
 
 #[derive(Default)]
 pub struct AccumulatedMap {
@@ -80,11 +80,7 @@ impl InputAccumulatedValues {
     }
 
     pub fn or_else(self, other: impl FnOnce() -> Self) -> Self {
-        if self.is_any() {
-            Self::Any
-        } else {
-            other()
-        }
+        if self.is_any() { Self::Any } else { other() }
     }
 }
 

src/active_query.rs

@@ -1,9 +1,10 @@
 use std::{fmt, mem, ops};
 
+use crate::Revision;
 #[cfg(feature = "accumulator")]
 use crate::accumulator::{
-    accumulated_map::{AccumulatedMap, AtomicInputAccumulatedValues, InputAccumulatedValues},
     Accumulator,
+    accumulated_map::{AccumulatedMap, AtomicInputAccumulatedValues, InputAccumulatedValues},
 };
 use crate::hash::FxIndexSet;
 use crate::key::DatabaseKeyIndex;
@@ -13,10 +14,9 @@ use crate::tracked_struct::{Disambiguator, DisambiguatorMap, IdentityHash, Ident
 use crate::zalsa_local::{
     QueryEdge, QueryEdgeKind, QueryOrigin, QueryRevisions, QueryRevisionsExtra,
 };
-use crate::Revision;
 use crate::{
-    cycle::{CycleHeads, IterationCount},
     Id,
+    cycle::{CycleHeads, IterationCount},
 };
 use crate::{durability::Durability, tracked_struct::Identity};
 

src/attach.rs

@@ -54,7 +54,9 @@ impl Attached {
                     Some(current_db) => {
                         let new_db = NonNull::from(db);
                         if !std::ptr::addr_eq(current_db.as_ptr(), new_db.as_ptr()) {
-                            panic!("Cannot change database mid-query. current: {current_db:?}, new: {new_db:?}");
+                            panic!(
+                                "Cannot change database mid-query. current: {current_db:?}, new: {new_db:?}"
+                            );
                         }
                         Self { state: None }
                     }

src/cycle.rs

@@ -45,11 +45,11 @@
 //! hangs (but not deadlocks).
 
 use std::iter::FusedIterator;
-use thin_vec::{thin_vec, ThinVec};
+use thin_vec::{ThinVec, thin_vec};
 
 use crate::key::DatabaseKeyIndex;
-use crate::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use crate::sync::OnceLock;
+use crate::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use crate::{Id, Revision};
 
 /// The maximum number of times we'll fixpoint-iterate before panicking.

src/event.rs

@@ -1,7 +1,7 @@
+use crate::Revision;
 use crate::cycle::IterationCount;
 use crate::key::DatabaseKeyIndex;
 use crate::sync::thread::{self, ThreadId};
-use crate::Revision;
 
 /// The `Event` struct identifies various notable things that can
 /// occur during salsa execution. Instances of this struct are given

src/function.rs

@@ -4,8 +4,8 @@ pub(crate) use sync::{ClaimGuard, ClaimResult, Reentrancy, SyncGuard, SyncOwner,
 use std::any::Any;
 use std::fmt;
 use std::ptr::NonNull;
-use std::sync::atomic::Ordering;
 use std::sync::OnceLock;
+use std::sync::atomic::Ordering;
 
 use crate::cycle::{CycleRecoveryStrategy, IterationCount, ProvisionalStatus};
 use crate::database::RawDatabase;
@@ -16,8 +16,8 @@ use crate::key::DatabaseKeyIndex;
 use crate::plumbing::{self, MemoIngredientMap};
 use crate::salsa_struct::SalsaStructInDb;
 use crate::sync::Arc;
-use crate::table::memo::MemoTableTypes;
 use crate::table::Table;
+use crate::table::memo::MemoTableTypes;
 use crate::views::DatabaseDownCaster;
 use crate::zalsa::{IngredientIndex, JarKind, MemoIngredientIndex, Zalsa};
 use crate::zalsa_local::{QueryEdge, QueryOriginRef};

src/function/backdate.rs

@@ -1,8 +1,8 @@
+use crate::Backtrace;
+use crate::DatabaseKeyIndex;
 use crate::function::memo::Memo;
 use crate::function::{Configuration, IngredientImpl};
 use crate::zalsa_local::QueryRevisions;
-use crate::Backtrace;
-use crate::DatabaseKeyIndex;
 use std::fmt;
 
 impl<C> IngredientImpl<C>

src/function/delete.rs

@@ -1,7 +1,7 @@
 use std::ptr::NonNull;
 
-use crate::function::memo::Memo;
 use crate::function::Configuration;
+use crate::function::memo::Memo;
 
 /// Stores the list of memos that have been deleted so they can be freed
 /// once the next revision starts. See the comment on the field

src/function/diff_outputs.rs

@@ -3,7 +3,7 @@ use crate::function::memo::Memo;
 use crate::function::{Configuration, IngredientImpl};
 use crate::hash::FxIndexSet;
 use crate::zalsa::Zalsa;
-use crate::zalsa_local::{output_edges, QueryOriginRef, QueryRevisions};
+use crate::zalsa_local::{QueryOriginRef, QueryRevisions, output_edges};
 use crate::{DatabaseKeyIndex, Event, EventKind};
 
 impl<C> IngredientImpl<C>

src/function/eviction/lru.rs

@@ -1,66 +1,66 @@
-//! Least Recently Used (LRU) eviction policy.
-//!
-//! This policy tracks the most recently accessed items and evicts
-//! the least recently used ones when the cache exceeds its capacity.
-
-use std::num::NonZeroUsize;
-
-use crate::hash::FxLinkedHashSet;
-use crate::sync::Mutex;
-use crate::Id;
-
-use super::{EvictionPolicy, HasCapacity};
-
-/// Least Recently Used eviction policy.
-///
-/// When the number of memoized values exceeds the configured capacity,
-/// the least recently accessed values are evicted at the start of each
-/// new revision.
-pub struct Lru {
-    capacity: Option<NonZeroUsize>,
-    set: Mutex<FxLinkedHashSet<Id>>,
-}
-
-impl Lru {
-    #[inline(never)]
-    fn insert(&self, id: Id) {
-        self.set.lock().insert(id);
-    }
-}
-
-impl EvictionPolicy for Lru {
-    fn new(cap: usize) -> Self {
-        Self {
-            capacity: NonZeroUsize::new(cap),
-            set: Mutex::default(),
-        }
-    }
-
-    #[inline(always)]
-    fn record_use(&self, id: Id) {
-        if self.capacity.is_some() {
-            self.insert(id);
-        }
-    }
-
-    fn set_capacity(&mut self, capacity: usize) {
-        self.capacity = NonZeroUsize::new(capacity);
-        if self.capacity.is_none() {
-            self.set.get_mut().clear();
-        }
-    }
-
-    fn for_each_evicted(&mut self, mut cb: impl FnMut(Id)) {
-        let Some(cap) = self.capacity else {
-            return;
-        };
-        let set = self.set.get_mut();
-        while set.len() > cap.get() {
-            if let Some(id) = set.pop_front() {
-                cb(id);
-            }
-        }
-    }
-}
-
-impl HasCapacity for Lru {}
+//! Least Recently Used (LRU) eviction policy.
+//!
+//! This policy tracks the most recently accessed items and evicts
+//! the least recently used ones when the cache exceeds its capacity.
+
+use std::num::NonZeroUsize;
+
+use crate::Id;
+use crate::hash::FxLinkedHashSet;
+use crate::sync::Mutex;
+
+use super::{EvictionPolicy, HasCapacity};
+
+/// Least Recently Used eviction policy.
+///
+/// When the number of memoized values exceeds the configured capacity,
+/// the least recently accessed values are evicted at the start of each
+/// new revision.
+pub struct Lru {
+    capacity: Option<NonZeroUsize>,
+    set: Mutex<FxLinkedHashSet<Id>>,
+}
+
+impl Lru {
+    #[inline(never)]
+    fn insert(&self, id: Id) {
+        self.set.lock().insert(id);
+    }
+}
+
+impl EvictionPolicy for Lru {
+    fn new(cap: usize) -> Self {
+        Self {
+            capacity: NonZeroUsize::new(cap),
+            set: Mutex::default(),
+        }
+    }
+
+    #[inline(always)]
+    fn record_use(&self, id: Id) {
+        if self.capacity.is_some() {
+            self.insert(id);
+        }
+    }
+
+    fn set_capacity(&mut self, capacity: usize) {
+        self.capacity = NonZeroUsize::new(capacity);
+        if self.capacity.is_none() {
+            self.set.get_mut().clear();
+        }
+    }
+
+    fn for_each_evicted(&mut self, mut cb: impl FnMut(Id)) {
+        let Some(cap) = self.capacity else {
+            return;
+        };
+        let set = self.set.get_mut();
+        while set.len() > cap.get() {
+            if let Some(id) = set.pop_front() {
+                cb(id);
+            }
+        }
+    }
+}
+
+impl HasCapacity for Lru {}