rust-analyzer

diff --git a/crates/salsa/src/derived.rs b/crates/salsa/src/derived.rs
index ede4230a7f..404e10e196 100644
--- a/crates/salsa/src/derived.rs
+++ b/crates/salsa/src/derived.rs

@@ -108,9 +108,7 @@ where

query_index: Q::QUERY_INDEX,

key_index,

};

- entry

- .or_insert_with(|| Arc::new(Slot::new(key.clone(), database_key_index)))

- .clone()

+ entry.or_insert_with(|| Arc::new(Slot::new(key.clone(), database_key_index))).clone()

}

@@ -152,13 +150,7 @@ where

assert_eq!(input.group_index, self.group_index);

assert_eq!(input.query_index, Q::QUERY_INDEX);

debug_assert!(revision < db.salsa_runtime().current_revision());

- let slot = self

- .slot_map

- .read()

- .get_index(input.key_index as usize)

- .unwrap()

- .1

- .clone();

+ let slot = self.slot_map.read().get_index(input.key_index as usize).unwrap().1.clone();

slot.maybe_changed_after(db, revision)

}

@@ -166,22 +158,17 @@ where

db.unwind_if_cancelled();

let slot = self.slot(key);

- let StampedValue {

- value,

- durability,

- changed_at,

- } = slot.read(db);

+ let StampedValue { value, durability, changed_at } = slot.read(db);

if let Some(evicted) = self.lru_list.record_use(&slot) {

evicted.evict();

}

- db.salsa_runtime()

- .report_query_read_and_unwind_if_cycle_resulted(

- slot.database_key_index(),

- durability,

- changed_at,

- );

+ db.salsa_runtime().report_query_read_and_unwind_if_cycle_resulted(

+ slot.database_key_index(),

+ durability,

+ changed_at,

+ );

value

}

@@ -195,10 +182,7 @@ where

C: std::iter::FromIterator<TableEntry<Q::Key, Q::Value>>,

{

let slot_map = self.slot_map.read();

- slot_map

- .values()

- .filter_map(|slot| slot.as_table_entry())

- .collect()

+ slot_map.values().filter_map(|slot| slot.as_table_entry()).collect()

}

diff --git a/crates/salsa/src/derived/slot.rs b/crates/salsa/src/derived/slot.rs
index 19d75f0775..957d628984 100644
--- a/crates/salsa/src/derived/slot.rs
+++ b/crates/salsa/src/derived/slot.rs

@@ -209,14 +209,7 @@ where

}

- self.execute(

- db,

- runtime,

- revision_now,

- active_query,

- panic_guard,

- old_memo,

- )

+ self.execute(db, runtime, revision_now, active_query, panic_guard, old_memo)

}

fn execute(

@@ -232,9 +225,7 @@ where

db.salsa_event(Event {

runtime_id: db.salsa_runtime().id(),

- kind: EventKind::WillExecute {

- database_key: self.database_key_index,

- },

+ kind: EventKind::WillExecute { database_key: self.database_key_index },

});

// Query was not previously executed, or value is potentially

@@ -310,22 +301,12 @@ where

changed_at: revisions.changed_at,

};

- let memo_value = if self.should_memoize_value(&self.key) {

- Some(new_value.value.clone())

- } else {

- None

- };

+ let memo_value =

+ if self.should_memoize_value(&self.key) { Some(new_value.value.clone()) } else { None };

- debug!(

- "read_upgrade({:?}): result.revisions = {:#?}",

- self, revisions,

- );

+ debug!("read_upgrade({:?}): result.revisions = {:#?}", self, revisions,);

- panic_guard.proceed(Some(Memo {

- value: memo_value,

- verified_at: revision_now,

- revisions,

- }));

+ panic_guard.proceed(Some(Memo { value: memo_value, verified_at: revision_now, revisions }));

new_value

}

@@ -388,10 +369,7 @@ where

value: value.clone(),

};

- info!(

- "{:?}: returning memoized value changed at {:?}",

- self, value.changed_at

- );

+ info!("{:?}: returning memoized value changed at {:?}", self, value.changed_at);

ProbeState::UpToDate(value)

} else {

@@ -503,11 +481,9 @@ where

// If we know when value last changed, we can return right away.

// Note that we don't need the actual value to be available.

ProbeState::NoValue(_, changed_at)

- | ProbeState::UpToDate(StampedValue {

- value: _,

- durability: _,

- changed_at,

- }) => MaybeChangedSinceProbeState::ChangedAt(changed_at),

+ | ProbeState::UpToDate(StampedValue { value: _, durability: _, changed_at }) => {

+ MaybeChangedSinceProbeState::ChangedAt(changed_at)

+ }

// If we have nothing cached, then value may have changed.

ProbeState::NotComputed(_) => MaybeChangedSinceProbeState::ChangedAt(revision_now),

@@ -561,14 +537,8 @@ where

// We found that this memoized value may have changed

// but we have an old value. We can re-run the code and

// actually *check* if it has changed.

- let StampedValue { changed_at, .. } = self.execute(

- db,

- runtime,

- revision_now,

- active_query,

- panic_guard,

- Some(old_memo),

- );

+ let StampedValue { changed_at, .. } =

+ self.execute(db, runtime, revision_now, active_query, panic_guard, Some(old_memo));

changed_at > revision

} else {

// We found that inputs to this memoized value may have chanced

@@ -605,10 +575,7 @@ where

Q: QueryFunction,

{

fn in_progress(id: RuntimeId) -> Self {

- QueryState::InProgress {

- id,

- anyone_waiting: Default::default(),

- }

+ QueryState::InProgress { id, anyone_waiting: Default::default() }

}

@@ -632,11 +599,7 @@ where

slot: &'me Slot<Q, MP>,

runtime: &'me Runtime,

) -> Self {

- Self {

- database_key_index,

- slot,

- runtime,

- }

+ Self { database_key_index, slot, runtime }

}

/// Indicates that we have concluded normally (without panicking).

@@ -674,8 +637,7 @@ where

// acquire a mutex; the mutex will guarantee that all writes

// we are interested in are visible.

if anyone_waiting.load(Ordering::Relaxed) {

- self.runtime

- .unblock_queries_blocked_on(self.database_key_index, wait_result);

+ self.runtime.unblock_queries_blocked_on(self.database_key_index, wait_result);

}

_ => panic!(

@@ -784,9 +746,8 @@ where

// are only interested in finding out whether the

// input changed *again*.

QueryInputs::Tracked { inputs } => {

- let changed_input = inputs

- .iter()

- .find(|&&input| db.maybe_changed_after(input, verified_at));

+ let changed_input =

+ inputs.iter().find(|&&input| db.maybe_changed_after(input, verified_at));

if let Some(input) = changed_input {

debug!("validate_memoized_value: `{:?}` may have changed", input);

diff --git a/crates/salsa/src/input.rs b/crates/salsa/src/input.rs
index edcff7e6b0..037e45b908 100644
--- a/crates/salsa/src/input.rs
+++ b/crates/salsa/src/input.rs

@@ -50,10 +50,7 @@ where

const CYCLE_STRATEGY: crate::plumbing::CycleRecoveryStrategy = CycleRecoveryStrategy::Panic;

fn new(group_index: u16) -> Self {

- InputStorage {

- group_index,

- slots: Default::default(),

- }

+ InputStorage { group_index, slots: Default::default() }

}

fn fmt_index(

@@ -91,18 +88,13 @@ where

.get(key)

.unwrap_or_else(|| panic!("no value set for {:?}({:?})", Q::default(), key));

- let StampedValue {

- value,

+ let StampedValue { value, durability, changed_at } = slot.stamped_value.read().clone();

+ db.salsa_runtime().report_query_read_and_unwind_if_cycle_resulted(

+ slot.database_key_index,

durability,

changed_at,

- } = slot.stamped_value.read().clone();

- db.salsa_runtime()

- .report_query_read_and_unwind_if_cycle_resulted(

- slot.database_key_index,

- durability,

- changed_at,

- );

+ );

value

}

@@ -133,10 +125,7 @@ where

Q: Query,

{

fn maybe_changed_after(&self, _db: &<Q as QueryDb<'_>>::DynDb, revision: Revision) -> bool {

- debug!(

- "maybe_changed_after(slot={:?}, revision={:?})",

- self, revision,

- );

+ debug!("maybe_changed_after(slot={:?}, revision={:?})", self, revision,);

let changed_at = self.stamped_value.read().changed_at;

@@ -160,13 +149,7 @@ where

Q: Query,

{

fn set(&self, runtime: &mut Runtime, key: &Q::Key, value: Q::Value, durability: Durability) {

- tracing::debug!(

- "{:?}({:?}) = {:?} ({:?})",

- Q::default(),

- key,

- value,

- durability

- );

+ tracing::debug!("{:?}({:?}) = {:?} ({:?})", Q::default(), key, value, durability);

// The value is changing, so we need a new revision (*). We also

// need to update the 'last changed' revision by invoking

@@ -190,11 +173,7 @@ where

// racing with somebody else to modify this same cell.

// (Otherwise, someone else might write a *newer* revision

// into the same cell while we block on the lock.)

- let stamped_value = StampedValue {

- value,

- durability,

- changed_at: next_revision,

- };

+ let stamped_value = StampedValue { value, durability, changed_at: next_revision };

match slots.entry(key.clone()) {

Entry::Occupied(entry) => {

diff --git a/crates/salsa/src/intern_id.rs b/crates/salsa/src/intern_id.rs
index f003706266..b060d8aab6 100644
--- a/crates/salsa/src/intern_id.rs
+++ b/crates/salsa/src/intern_id.rs

@@ -63,9 +63,7 @@ impl InternId {

/// `value` must be less than `MAX`

pub const unsafe fn new_unchecked(value: u32) -> Self {

debug_assert!(value < InternId::MAX);

- InternId {

- value: NonZeroU32::new_unchecked(value + 1),

- }

+ InternId { value: NonZeroU32::new_unchecked(value + 1) }

}

/// Convert this raw-id into a u32 value.

diff --git a/crates/salsa/src/interned.rs b/crates/salsa/src/interned.rs
index dd986bc5d1..392534ea0b 100644
--- a/crates/salsa/src/interned.rs
+++ b/crates/salsa/src/interned.rs

@@ -110,10 +110,7 @@ where

K: Eq + Hash,

{

fn default() -> Self {

- Self {

- map: Default::default(),

- values: Default::default(),

- }

+ Self { map: Default::default(), values: Default::default() }

}

@@ -159,11 +156,7 @@ where

query_index: Q::QUERY_INDEX,

key_index: index.as_u32(),

};

- Arc::new(Slot {

- database_key_index,

- value: owned_key2,

- interned_at: revision_now,

- })

+ Arc::new(Slot { database_key_index, value: owned_key2, interned_at: revision_now })

};

let (slot, index);

@@ -194,10 +187,7 @@ where

const CYCLE_STRATEGY: crate::plumbing::CycleRecoveryStrategy = CycleRecoveryStrategy::Panic;

fn new(group_index: u16) -> Self {

- InternedStorage {

- group_index,

- tables: RwLock::new(InternTables::default()),

- }

+ InternedStorage { group_index, tables: RwLock::new(InternTables::default()) }

}

fn fmt_index(

@@ -231,12 +221,11 @@ where

db.unwind_if_cancelled();

let (slot, index) = self.intern_index(db, key);

let changed_at = slot.interned_at;

- db.salsa_runtime()

- .report_query_read_and_unwind_if_cycle_resulted(

- slot.database_key_index,

- INTERN_DURABILITY,

- changed_at,

- );

+ db.salsa_runtime().report_query_read_and_unwind_if_cycle_resulted(

+ slot.database_key_index,

+ INTERN_DURABILITY,

+ changed_at,

+ );

<Q::Value>::from_intern_id(index)

}

@@ -313,9 +302,7 @@ where

const CYCLE_STRATEGY: CycleRecoveryStrategy = CycleRecoveryStrategy::Panic;

fn new(_group_index: u16) -> Self {

- LookupInternedStorage {

- phantom: std::marker::PhantomData,

- }

+ LookupInternedStorage { phantom: std::marker::PhantomData }

}

fn fmt_index(

@@ -350,12 +337,11 @@ where

let slot = interned_storage.lookup_value(index);

let value = slot.value.clone();

let interned_at = slot.interned_at;

- db.salsa_runtime()

- .report_query_read_and_unwind_if_cycle_resulted(

- slot.database_key_index,

- INTERN_DURABILITY,

- interned_at,

- );

+ db.salsa_runtime().report_query_read_and_unwind_if_cycle_resulted(

+ slot.database_key_index,

+ INTERN_DURABILITY,

+ interned_at,

+ );

value

}

diff --git a/crates/salsa/src/lib.rs b/crates/salsa/src/lib.rs
index 2ed5d0d131..19a9fd2571 100644
--- a/crates/salsa/src/lib.rs
+++ b/crates/salsa/src/lib.rs

@@ -216,18 +216,14 @@ impl fmt::Debug for EventKind {

.debug_struct("DidValidateMemoizedValue")

.field("database_key", database_key)

.finish(),

- EventKind::WillBlockOn {

- other_runtime_id,

- database_key,

- } => fmt

+ EventKind::WillBlockOn { other_runtime_id, database_key } => fmt

.debug_struct("WillBlockOn")

.field("other_runtime_id", other_runtime_id)

.field("database_key", database_key)

.finish(),

- EventKind::WillExecute { database_key } => fmt

- .debug_struct("WillExecute")

- .field("database_key", database_key)

- .finish(),

+ EventKind::WillExecute { database_key } => {

+ fmt.debug_struct("WillExecute").field("database_key", database_key).finish()

+ }

EventKind::WillCheckCancellation => fmt.debug_struct("WillCheckCancellation").finish(),

}

@@ -251,10 +247,7 @@ where

.debug_struct("DidValidateMemoizedValue")

.field("database_key", &database_key.debug(self.db))

.finish(),

- EventKind::WillBlockOn {

- other_runtime_id,

- database_key,

- } => fmt

+ EventKind::WillBlockOn { other_runtime_id, database_key } => fmt

.debug_struct("WillBlockOn")

.field("other_runtime_id", &other_runtime_id)

.field("database_key", &database_key.debug(self.db))

@@ -707,9 +700,7 @@ impl Cycle {

/// Returns a vector with the debug information for

/// all the participants in the cycle.

pub fn all_participants<DB: ?Sized + Database>(&self, db: &DB) -> Vec<String> {

- self.participant_keys()

- .map(|d| format!("{:?}", d.debug(db)))

- .collect()

+ self.participant_keys().map(|d| format!("{:?}", d.debug(db))).collect()

}

/// Returns a vector with the debug information for

@@ -733,18 +724,12 @@ impl Cycle {

fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

fmt.debug_struct("UnexpectedCycle")

.field("all_participants", &self.c.all_participants(self.db))

- .field(

- "unexpected_participants",

- &self.c.unexpected_participants(self.db),

- )

+ .field("unexpected_participants", &self.c.unexpected_participants(self.db))

.finish()

}

- UnexpectedCycleDebug {

- c: self,

- db: db.ops_database(),

- }

+ UnexpectedCycleDebug { c: self, db: db.ops_database() }

}

diff --git a/crates/salsa/src/lru.rs b/crates/salsa/src/lru.rs
index 39dd9dfe8c..bd54168ca2 100644
--- a/crates/salsa/src/lru.rs
+++ b/crates/salsa/src/lru.rs

@@ -68,10 +68,7 @@ where

#[cfg_attr(not(test), allow(dead_code))]

fn with_seed(seed: &str) -> Self {

- Lru {

- green_zone: AtomicUsize::new(0),

- data: Mutex::new(LruData::with_seed(seed)),

- }

+ Lru { green_zone: AtomicUsize::new(0), data: Mutex::new(LruData::with_seed(seed)) }

}

/// Adjust the total number of nodes permitted to have a value at

@@ -143,13 +140,7 @@ where

}

fn with_rng(rng: Rand64) -> Self {

- LruData {

- end_yellow_zone: 0,

- end_green_zone: 0,

- end_red_zone: 0,

- entries: Vec::new(),

- rng,

- }

+ LruData { end_yellow_zone: 0, end_green_zone: 0, end_red_zone: 0, entries: Vec::new(), rng }

}

fn green_zone(&self) -> std::ops::Range<usize> {

@@ -294,9 +285,7 @@ where

impl Default for LruIndex {

fn default() -> Self {

- Self {

- index: AtomicUsize::new(std::usize::MAX),

- }

+ Self { index: AtomicUsize::new(std::usize::MAX) }

}

diff --git a/crates/salsa/src/plumbing.rs b/crates/salsa/src/plumbing.rs
index c047b9f12a..f09d6d7337 100644
--- a/crates/salsa/src/plumbing.rs
+++ b/crates/salsa/src/plumbing.rs

@@ -78,10 +78,7 @@ pub trait QueryFunction: Query {

key: &Self::Key,

) -> Self::Value {

let _ = (db, cycle, key);

- panic!(

- "query `{:?}` doesn't support cycle fallback",

- Self::default()

- )

+ panic!("query `{:?}` doesn't support cycle fallback", Self::default())

}

diff --git a/crates/salsa/src/revision.rs b/crates/salsa/src/revision.rs
index f97295ced6..61d38a3bcc 100644
--- a/crates/salsa/src/revision.rs
+++ b/crates/salsa/src/revision.rs

@@ -21,9 +21,7 @@ impl Revision {

}

pub(crate) fn from(g: u32) -> Self {

- Self {

- generation: NonZeroU32::new(g).unwrap(),

- }

+ Self { generation: NonZeroU32::new(g).unwrap() }

}

pub(crate) fn next(self) -> Revision {

@@ -48,9 +46,7 @@ pub(crate) struct AtomicRevision {

impl AtomicRevision {

pub(crate) fn start() -> Self {

- Self {

- data: AtomicU32::new(START),

- }

+ Self { data: AtomicU32::new(START) }

}

pub(crate) fn load(&self) -> Revision {

diff --git a/crates/salsa/src/runtime.rs b/crates/salsa/src/runtime.rs
index 29fe68bd3d..29c5afa37a 100644
--- a/crates/salsa/src/runtime.rs
+++ b/crates/salsa/src/runtime.rs

@@ -85,9 +85,7 @@ impl Runtime {

let revision_guard = RevisionGuard::new(&self.shared_state);

- let id = RuntimeId {

- counter: self.shared_state.next_id.fetch_add(1, Ordering::SeqCst),

- };

+ let id = RuntimeId { counter: self.shared_state.next_id.fetch_add(1, Ordering::SeqCst) };

Runtime {

id,

@@ -242,8 +240,7 @@ impl Runtime {

/// Queries which report untracked reads will be re-executed in the next

/// revision.

pub fn report_untracked_read(&self) {

- self.local_state

- .report_untracked_read(self.current_revision());

+ self.local_state.report_untracked_read(self.current_revision());

}

/// Acts as though the current query had read an input with the given durability; this will force the current query's durability to be at most `durability`.

@@ -251,8 +248,7 @@ impl Runtime {

/// This is mostly useful to control the durability level for [on-demand inputs](https://salsa-rs.github.io/salsa/common_patterns/on_demand_inputs.html).

pub fn report_synthetic_read(&self, durability: Durability) {

let changed_at = self.last_changed_revision(durability);

- self.local_state

- .report_synthetic_read(durability, changed_at);

+ self.local_state.report_synthetic_read(durability, changed_at);

}

/// Handles a cycle in the dependency graph that was detected when the

@@ -270,10 +266,7 @@ impl Runtime {

database_key_index: DatabaseKeyIndex,

to_id: RuntimeId,

) {

- debug!(

- "unblock_cycle_and_maybe_throw(database_key={:?})",

- database_key_index

- );

+ debug!("unblock_cycle_and_maybe_throw(database_key={:?})", database_key_index);

let mut from_stack = self.local_state.take_query_stack();

let from_id = self.id();

@@ -312,11 +305,7 @@ impl Runtime {

Cycle::new(Arc::new(v))

};

- debug!(

- "cycle {:?}, cycle_query {:#?}",

- cycle.debug(db),

- cycle_query,

- );

+ debug!("cycle {:?}, cycle_query {:#?}", cycle.debug(db), cycle_query,);

// We can remove the cycle participants from the list of dependencies;

// they are a strongly connected component (SCC) and we only care about

@@ -329,12 +318,10 @@ impl Runtime {

// are going to be unwound so that fallback can occur.

dg.for_each_cycle_participant(from_id, &mut from_stack, database_key_index, to_id, |aqs| {

aqs.iter_mut()

- .skip_while(

- |aq| match db.cycle_recovery_strategy(aq.database_key_index) {

- CycleRecoveryStrategy::Panic => true,

- CycleRecoveryStrategy::Fallback => false,

- },

- )

+ .skip_while(|aq| match db.cycle_recovery_strategy(aq.database_key_index) {

+ CycleRecoveryStrategy::Panic => true,

+ CycleRecoveryStrategy::Fallback => false,

+ })

.for_each(|aq| {

debug!("marking {:?} for fallback", aq.database_key_index.debug(db));

aq.take_inputs_from(&cycle_query);

@@ -404,10 +391,7 @@ impl Runtime {

db.salsa_event(Event {

runtime_id: self.id(),

- kind: EventKind::WillBlockOn {

- other_runtime_id: other_id,

- database_key,

- },

+ kind: EventKind::WillBlockOn { other_runtime_id: other_id, database_key },

});

let stack = self.local_state.take_query_stack();

@@ -585,18 +569,12 @@ impl ActiveQuery {

if dependencies.is_empty() {

QueryInputs::NoInputs

} else {

- QueryInputs::Tracked {

- inputs: dependencies.iter().copied().collect(),

- }

+ QueryInputs::Tracked { inputs: dependencies.iter().copied().collect() }

}

};

- QueryRevisions {

- changed_at: self.changed_at,

- inputs,

- durability: self.durability,

- }

+ QueryRevisions { changed_at: self.changed_at, inputs, durability: self.durability }

}

/// Adds any dependencies from `other` into `self`.

@@ -673,9 +651,7 @@ impl RevisionGuard {

shared_state.query_lock.raw().lock_shared_recursive();

}

- Self {

- shared_state: shared_state.clone(),

- }

+ Self { shared_state: shared_state.clone() }

}

diff --git a/crates/salsa/src/runtime/dependency_graph.rs b/crates/salsa/src/runtime/dependency_graph.rs
index f69524b7fb..9fa2851d0e 100644
--- a/crates/salsa/src/runtime/dependency_graph.rs
+++ b/crates/salsa/src/runtime/dependency_graph.rs

@@ -103,21 +103,14 @@ impl DependencyGraph {

// load up the next thread (i.e., we start at B/QB2,

// and then load up the dependency on C/QC2).

let edge = self.edges.get_mut(&id).unwrap();

- let prefix = edge

- .stack

- .iter_mut()

- .take_while(|p| p.database_key_index != key)

- .count();

+ let prefix = edge.stack.iter_mut().take_while(|p| p.database_key_index != key).count();

closure(&mut edge.stack[prefix..]);

id = edge.blocked_on_id;

key = edge.blocked_on_key;

}

// Finally, we copy in the results from `from_stack`.

- let prefix = from_stack

- .iter_mut()

- .take_while(|p| p.database_key_index != key)

- .count();

+ let prefix = from_stack.iter_mut().take_while(|p| p.database_key_index != key).count();

closure(&mut from_stack[prefix..]);

}

@@ -141,24 +134,13 @@ impl DependencyGraph {

let mut others_unblocked = false;

while id != from_id {

let edge = self.edges.get(&id).unwrap();

- let prefix = edge

- .stack

- .iter()

- .take_while(|p| p.database_key_index != key)

- .count();

+ let prefix = edge.stack.iter().take_while(|p| p.database_key_index != key).count();

let next_id = edge.blocked_on_id;

let next_key = edge.blocked_on_key;

- if let Some(cycle) = edge.stack[prefix..]

- .iter()

- .rev()

- .find_map(|aq| aq.cycle.clone())

- {

+ if let Some(cycle) = edge.stack[prefix..].iter().rev().find_map(|aq| aq.cycle.clone()) {

// Remove `id` from the list of runtimes blocked on `next_key`:

- self.query_dependents

- .get_mut(&next_key)

- .unwrap()

- .retain(|r| *r != id);

+ self.query_dependents.get_mut(&next_key).unwrap().retain(|r| *r != id);

// Unblock runtime so that it can resume execution once lock is released:

self.unblock_runtime(id, WaitResult::Cycle(cycle));

@@ -170,10 +152,7 @@ impl DependencyGraph {

key = next_key;

}

- let prefix = from_stack

- .iter()

- .take_while(|p| p.database_key_index != key)

- .count();

+ let prefix = from_stack.iter().take_while(|p| p.database_key_index != key).count();

let this_unblocked = from_stack[prefix..].iter().any(|aq| aq.cycle.is_some());

(this_unblocked, others_unblocked)

@@ -239,10 +218,7 @@ impl DependencyGraph {

condvar: condvar.clone(),

);

- self.query_dependents

- .entry(database_key)

- .or_default()

- .push(from_id);

+ self.query_dependents.entry(database_key).or_default().push(from_id);

condvar

}

@@ -253,10 +229,7 @@ impl DependencyGraph {

database_key: DatabaseKeyIndex,

wait_result: WaitResult,

) {

- let dependents = self

- .query_dependents

- .remove(&database_key)

- .unwrap_or_default();

+ let dependents = self.query_dependents.remove(&database_key).unwrap_or_default();

for from_id in dependents {

self.unblock_runtime(from_id, wait_result.clone());

diff --git a/crates/salsa/src/runtime/local_state.rs b/crates/salsa/src/runtime/local_state.rs
index b6c3573f00..b21f1ee4af 100644
--- a/crates/salsa/src/runtime/local_state.rs
+++ b/crates/salsa/src/runtime/local_state.rs

@@ -53,9 +53,7 @@ pub(crate) enum QueryInputs {

impl Default for LocalState {

fn default() -> Self {

- LocalState {

- query_stack: RefCell::new(Some(Vec::new())),

- }

+ LocalState { query_stack: RefCell::new(Some(Vec::new())) }

}

@@ -65,19 +63,11 @@ impl LocalState {

let mut query_stack = self.query_stack.borrow_mut();

let query_stack = query_stack.as_mut().expect("local stack taken");

query_stack.push(ActiveQuery::new(database_key_index));

- ActiveQueryGuard {

- local_state: self,

- database_key_index,

- push_len: query_stack.len(),

- }

+ ActiveQueryGuard { local_state: self, database_key_index, push_len: query_stack.len() }

}

fn with_query_stack<R>(&self, c: impl FnOnce(&mut Vec<ActiveQuery>) -> R) -> R {

- c(self

- .query_stack

- .borrow_mut()

- .as_mut()

- .expect("query stack taken"))

+ c(self.query_stack.borrow_mut().as_mut().expect("query stack taken"))

}

pub(super) fn query_in_progress(&self) -> bool {

@@ -86,9 +76,7 @@ impl LocalState {

pub(super) fn active_query(&self) -> Option<DatabaseKeyIndex> {

self.with_query_stack(|stack| {

- stack

- .last()

- .map(|active_query| active_query.database_key_index)

+ stack.last().map(|active_query| active_query.database_key_index)

})

}

@@ -156,10 +144,7 @@ impl LocalState {

/// the current thread is blocking. The stack must be restored

/// with [`Self::restore_query_stack`] when the thread unblocks.

pub(super) fn take_query_stack(&self) -> Vec<ActiveQuery> {

- assert!(

- self.query_stack.borrow().is_some(),

- "query stack already taken"

- );

+ assert!(self.query_stack.borrow().is_some(), "query stack already taken");

self.query_stack.take().unwrap()

}

@@ -188,10 +173,7 @@ impl ActiveQueryGuard<'_> {

self.local_state.with_query_stack(|stack| {

// Sanity check: pushes and pops should be balanced.

assert_eq!(stack.len(), self.push_len);

- debug_assert_eq!(

- stack.last().unwrap().database_key_index,

- self.database_key_index

- );

+ debug_assert_eq!(stack.last().unwrap().database_key_index, self.database_key_index);

stack.pop().unwrap()

})

}

@@ -220,8 +202,7 @@ impl ActiveQueryGuard<'_> {

/// If the active query is registered as a cycle participant, remove and

/// return that cycle.

pub(crate) fn take_cycle(&self) -> Option<Cycle> {

- self.local_state

- .with_query_stack(|stack| stack.last_mut()?.cycle.take())

+ self.local_state.with_query_stack(|stack| stack.last_mut()?.cycle.take())

}

diff --git a/crates/salsa/src/storage.rs b/crates/salsa/src/storage.rs
index 5e32633002..e0acf44041 100644
--- a/crates/salsa/src/storage.rs
+++ b/crates/salsa/src/storage.rs

@@ -12,10 +12,7 @@ pub struct Storage<DB: DatabaseStorageTypes> {

impl<DB: DatabaseStorageTypes> Default for Storage<DB> {

fn default() -> Self {

- Self {

- query_store: Default::default(),

- runtime: Default::default(),

- }

+ Self { query_store: Default::default(), runtime: Default::default() }

}

@@ -51,9 +48,6 @@ impl<DB: DatabaseStorageTypes> Storage<DB> {

/// thread. Using two database handles from the **same thread** can lead to

/// deadlock.

pub fn snapshot(&self) -> Self {

- Storage {

- query_store: self.query_store.clone(),

- runtime: self.runtime.snapshot(),

- }

+ Storage { query_store: self.query_store.clone(), runtime: self.runtime.snapshot() }

}

diff --git a/crates/salsa/tests/cycles.rs b/crates/salsa/tests/cycles.rs
index 004f866b83..4c3ec312f2 100644
--- a/crates/salsa/tests/cycles.rs
+++ b/crates/salsa/tests/cycles.rs

@@ -58,17 +58,13 @@ impl salsa::Database for DatabaseImpl {}

impl ParallelDatabase for DatabaseImpl {

fn snapshot(&self) -> Snapshot<Self> {

- Snapshot::new(DatabaseImpl {

- storage: self.storage.snapshot(),

- })

+ Snapshot::new(DatabaseImpl { storage: self.storage.snapshot() })

}

impl Default for DatabaseImpl {

fn default() -> Self {

- let res = DatabaseImpl {

- storage: salsa::Storage::default(),

- };

+ let res = DatabaseImpl { storage: salsa::Storage::default() };

res

}

@@ -113,15 +109,11 @@ trait Database: salsa::Database {

}

fn recover_a(db: &dyn Database, cycle: &salsa::Cycle) -> Result<(), Error> {

- Err(Error {

- cycle: cycle.all_participants(db),

- })

+ Err(Error { cycle: cycle.all_participants(db) })

}

fn recover_b(db: &dyn Database, cycle: &salsa::Cycle) -> Result<(), Error> {

- Err(Error {

- cycle: cycle.all_participants(db),

- })

+ Err(Error { cycle: cycle.all_participants(db) })

}

fn memoized_a(db: &dyn Database) {

diff --git a/crates/salsa/tests/incremental/constants.rs b/crates/salsa/tests/incremental/constants.rs
index 30f42b136d..ea0eb81978 100644
--- a/crates/salsa/tests/incremental/constants.rs
+++ b/crates/salsa/tests/incremental/constants.rs

@@ -111,10 +111,7 @@ fn becomes_constant_with_change() {

db.set_input_with_durability('b', 45, Durability::MEDIUM);

assert_eq!(db.add('a', 'b'), 68);

- assert_eq!(

- Durability::MEDIUM,

- AddQuery.in_db(&db).durability(('a', 'b'))

- );

+ assert_eq!(Durability::MEDIUM, AddQuery.in_db(&db).durability(('a', 'b')));

}

// Test a subtle case in which an input changes from constant to

diff --git a/crates/salsa/tests/interned.rs b/crates/salsa/tests/interned.rs
index bf8683114c..b9b916d19a 100644
--- a/crates/salsa/tests/interned.rs
+++ b/crates/salsa/tests/interned.rs

@@ -12,9 +12,7 @@ impl salsa::Database for Database {}

impl salsa::ParallelDatabase for Database {

fn snapshot(&self) -> salsa::Snapshot<Self> {

- salsa::Snapshot::new(Database {

- storage: self.storage.snapshot(),

- })

+ salsa::Snapshot::new(Database { storage: self.storage.snapshot() })

}

@@ -71,14 +69,8 @@ fn test_intern2() {

assert_eq!(bar0, bar1);

assert_ne!(foo0, bar0);

- assert_eq!(

- ("x".to_string(), "foo".to_string()),

- db.lookup_intern2(foo0)

- );

- assert_eq!(

- ("x".to_string(), "bar".to_string()),

- db.lookup_intern2(bar0)

- );

+ assert_eq!(("x".to_string(), "foo".to_string()), db.lookup_intern2(foo0));

+ assert_eq!(("x".to_string(), "bar".to_string()), db.lookup_intern2(bar0));

}

#[test]

diff --git a/crates/salsa/tests/on_demand_inputs.rs b/crates/salsa/tests/on_demand_inputs.rs
index 990920256a..2ad4975eff 100644
--- a/crates/salsa/tests/on_demand_inputs.rs
+++ b/crates/salsa/tests/on_demand_inputs.rs

@@ -16,11 +16,7 @@ trait QueryGroup: salsa::Database + AsRef<HashMap<u32, u32>> {

}

fn a(db: &dyn QueryGroup, x: u32) -> u32 {

- let durability = if x % 2 == 0 {

- Durability::LOW

- } else {

- Durability::HIGH

- };

+ let durability = if x % 2 == 0 { Durability::LOW } else { Durability::HIGH };

db.salsa_runtime().report_synthetic_read(durability);

let external_state: &HashMap<u32, u32> = db.as_ref();

external_state[&x]

diff --git a/crates/salsa/tests/panic_safely.rs b/crates/salsa/tests/panic_safely.rs
index e51a74e1f1..c11ae9c214 100644
--- a/crates/salsa/tests/panic_safely.rs
+++ b/crates/salsa/tests/panic_safely.rs

@@ -33,9 +33,7 @@ impl salsa::Database for DatabaseStruct {}

impl salsa::ParallelDatabase for DatabaseStruct {

fn snapshot(&self) -> Snapshot<Self> {

- Snapshot::new(DatabaseStruct {

- storage: self.storage.snapshot(),

- })

+ Snapshot::new(DatabaseStruct { storage: self.storage.snapshot() })

}

diff --git a/crates/salsa/tests/parallel/parallel_cycle_none_recover.rs b/crates/salsa/tests/parallel/parallel_cycle_none_recover.rs
index 65f1b6ea16..1467041422 100644
--- a/crates/salsa/tests/parallel/parallel_cycle_none_recover.rs
+++ b/crates/salsa/tests/parallel/parallel_cycle_none_recover.rs

@@ -37,11 +37,7 @@ fn parallel_cycle_none_recover() {

// We expect A to propagate a panic, which causes us to use the sentinel

// type `Canceled`.

- assert!(thread_a

- .join()

- .unwrap_err()

- .downcast_ref::<salsa::Cycle>()

- .is_some());

+ assert!(thread_a.join().unwrap_err().downcast_ref::<salsa::Cycle>().is_some());

}

#[salsa::query_group(ParallelCycleNoneRecover)]

diff --git a/crates/salsa/tests/parallel/stress.rs b/crates/salsa/tests/parallel/stress.rs
index 16a1b79044..2fa317b2b9 100644
--- a/crates/salsa/tests/parallel/stress.rs
+++ b/crates/salsa/tests/parallel/stress.rs

@@ -38,9 +38,7 @@ impl salsa::Database for StressDatabaseImpl {}

impl salsa::ParallelDatabase for StressDatabaseImpl {

fn snapshot(&self) -> Snapshot<StressDatabaseImpl> {

- Snapshot::new(StressDatabaseImpl {

- storage: self.storage.snapshot(),

- })

+ Snapshot::new(StressDatabaseImpl { storage: self.storage.snapshot() })

}

@@ -53,10 +51,7 @@ enum Query {

enum MutatorOp {

WriteOp(WriteOp),

- LaunchReader {

- ops: Vec<ReadOp>,

- check_cancellation: bool,

- },

+ LaunchReader { ops: Vec<ReadOp>, check_cancellation: bool },

}

#[derive(Debug)]

@@ -158,13 +153,12 @@ fn stress_test() {

for op in write_ops {

match op {

MutatorOp::WriteOp(w) => w.execute(&mut db),

- MutatorOp::LaunchReader {

- ops,

- check_cancellation,

- } => all_threads.push(std::thread::spawn({

- let db = db.snapshot();

- move || Cancelled::catch(|| db_reader_thread(&db, ops, check_cancellation))

- })),

+ MutatorOp::LaunchReader { ops, check_cancellation } => {

+ all_threads.push(std::thread::spawn({

+ let db = db.snapshot();

+ move || Cancelled::catch(|| db_reader_thread(&db, ops, check_cancellation))

+ }))

+ }

}

diff --git a/crates/salsa/tests/parallel/true_parallel.rs b/crates/salsa/tests/parallel/true_parallel.rs
index 03432dca97..d0e58efd1a 100644
--- a/crates/salsa/tests/parallel/true_parallel.rs
+++ b/crates/salsa/tests/parallel/true_parallel.rs

@@ -18,11 +18,10 @@ fn true_parallel_different_keys() {

let thread1 = std::thread::spawn({

let db = db.snapshot();

move || {

- let v = db.knobs().sum_signal_on_entry.with_value(1, || {

- db.knobs()

- .sum_wait_for_on_exit

- .with_value(2, || db.sum("a"))

- });

+ let v = db

+ .knobs()

+ .sum_signal_on_entry

+ .with_value(1, || db.knobs().sum_wait_for_on_exit.with_value(2, || db.sum("a")));

}

});

@@ -32,9 +31,10 @@ fn true_parallel_different_keys() {

let thread2 = std::thread::spawn({

let db = db.snapshot();

move || {

- let v = db.knobs().sum_wait_for_on_entry.with_value(1, || {

- db.knobs().sum_signal_on_exit.with_value(2, || db.sum("b"))

- });

+ let v = db

+ .knobs()

+ .sum_wait_for_on_entry

+ .with_value(1, || db.knobs().sum_signal_on_exit.with_value(2, || db.sum("b")));

}

});

@@ -58,11 +58,10 @@ fn true_parallel_same_keys() {

let thread1 = std::thread::spawn({

let db = db.snapshot();

move || {

- let v = db.knobs().sum_signal_on_entry.with_value(1, || {

- db.knobs()

- .sum_wait_for_on_entry

- .with_value(2, || db.sum("abc"))

- });

+ let v = db

+ .knobs()

+ .sum_signal_on_entry

+ .with_value(1, || db.knobs().sum_wait_for_on_entry.with_value(2, || db.sum("abc")));

}

});

@@ -99,9 +98,9 @@ fn true_parallel_propagate_panic() {

let db = db.snapshot();

move || {

let v = db.knobs().sum_signal_on_entry.with_value(1, || {

- db.knobs().sum_wait_for_on_entry.with_value(2, || {

- db.knobs().sum_should_panic.with_value(true, || db.sum("a"))

- })

+ db.knobs()

+ .sum_wait_for_on_entry

+ .with_value(2, || db.knobs().sum_should_panic.with_value(true, || db.sum("a")))

});

}