Merge pull request #630 from Veykril/veykril/push-mwwmzmpskxnr

Give Durability niches

Author: davidbarsky

src/active_query.rs

@@ -86,7 +86,7 @@ impl ActiveQuery {
 
     pub(super) fn add_untracked_read(&mut self, changed_at: Revision) {
         self.untracked_read = true;
-        self.durability = Durability::LOW;
+        self.durability = Durability::MIN;
         self.changed_at = changed_at;
     }
 

src/durability.rs

@@ -16,33 +16,54 @@
 /// frequently editing. Medium or high durabilities are used for
 /// configuration, the source from library crates, or other things
 /// that are unlikely to be edited.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Durability(u8);
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Durability(DurabilityVal);
+
+impl std::fmt::Debug for Durability {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Durability")
+            .field(&(self.0 as usize))
+            .finish()
+    }
+}
+
+// We use an enum here instead of a u8 for niches.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum DurabilityVal {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+}
 
 impl Durability {
     /// Low durability: things that change frequently.
     ///
     /// Example: part of the crate being edited
-    pub const LOW: Durability = Durability(0);
+    pub const LOW: Durability = Durability(DurabilityVal::Low);
 
     /// Medium durability: things that change sometimes, but rarely.
     ///
     /// Example: a Cargo.toml file
-    pub const MEDIUM: Durability = Durability(1);
+    pub const MEDIUM: Durability = Durability(DurabilityVal::Medium);
 
     /// High durability: things that are not expected to change under
     /// common usage.
     ///
     /// Example: the standard library or something from crates.io
-    pub const HIGH: Durability = Durability(2);
+    pub const HIGH: Durability = Durability(DurabilityVal::High);
+
+    /// The minimum possible durability; equivalent to LOW but
+    /// "conceptually" distinct (i.e., if we add more durability
+    /// levels, this could change).
+    pub(crate) const MIN: Durability = Self::LOW;
 
     /// The maximum possible durability; equivalent to HIGH but
     /// "conceptually" distinct (i.e., if we add more durability
     /// levels, this could change).
     pub(crate) const MAX: Durability = Self::HIGH;
 
     /// Number of durability levels.
-    pub(crate) const LEN: usize = 3;
+    pub(crate) const LEN: usize = Self::HIGH.0 as usize + 1;
 
     pub(crate) fn index(self) -> usize {
         self.0 as usize

src/input.rs

@@ -150,7 +150,7 @@ impl<C: Configuration> IngredientImpl<C> {
 
         let stamp = &mut r.stamps[field_index];
 
-        if stamp.durability != Durability::LOW {
+        if stamp.durability != Durability::MIN {
             runtime.report_tracked_write(stamp.durability);
         }
 

src/runtime.rs

@@ -35,7 +35,7 @@ pub struct Runtime {
     /// revisions[i + 1]`, for all `i`. This is because when you
     /// modify a value with durability D, that implies that values
     /// with durability less than D may have changed too.
-    revisions: Box<[AtomicRevision; Durability::LEN]>,
+    revisions: [AtomicRevision; Durability::LEN],
 
     /// The dependency graph tracks which runtimes are blocked on one
     /// another, waiting for queries to terminate.
@@ -81,7 +81,7 @@ impl<V> StampedValue<V> {
 impl Default for Runtime {
     fn default() -> Self {
         Runtime {
-            revisions: Box::new([const { AtomicRevision::start() }; Durability::LEN]),
+            revisions: [const { AtomicRevision::start() }; Durability::LEN],
             revision_canceled: Default::default(),
             dependency_graph: Default::default(),
             table: Default::default(),