rustfmt

Author: Veykril

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,36 +150,25 @@ 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)
     }
 
     fn fetch(&self, db: &<Q as QueryDb<'_>>::DynDb, key: &Q::Key) -> Q::Value {
         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()
     }
 }
 

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);
 

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) => {

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.

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
     }