perf(specifier): lazily create node_[range|version]

JamieMason · JamieMason · commit f46fa236fd02 · 2026-03-21T21:26:52.000Z
diff --git a/crates/syncpack-specifier/src/latest.rs b/crates/syncpack-specifier/src/latest.rs
@@ -1,32 +1,50 @@
 use {
-  crate::{semver_range::SemverRange, Specifier},
-  std::rc::Rc,
+  crate::{semver_range::SemverRange, Specifier, HUGE},
+  std::{cell::OnceCell, rc::Rc},
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Latest {
-  /// "*"
-  /// "latest"
-  /// "x"
+  /// "*", "latest", "x"
   pub raw: String,
-  /// Used for ordering - Latest gets the HUGE version (999999.999999.999999)
-  /// so it sorts after all real versions
-  pub node_version: Rc<node_semver::Version>,
+  /// Lazily parsed HUGE version for ordering (999999.999999.999999)
+  node_version: OnceCell<Rc<node_semver::Version>>,
   /// The semver range is always Any for Latest
   pub semver_range: SemverRange,
 }
 
+impl PartialEq for Latest {
+  fn eq(&self, other: &Self) -> bool {
+    self.raw == other.raw && self.semver_range == other.semver_range
+  }
+}
+
 impl Latest {
   pub fn create(raw: &str) -> Specifier {
-    let huge = crate::HUGE.to_string();
-    let huge_version = format!("{huge}.{huge}.{huge}");
-    match Specifier::new_node_version(&huge_version) {
-      Some(node_version) => Specifier::Latest(Self {
-        raw: raw.to_string(),
-        node_version,
-        semver_range: SemverRange::Any,
-      }),
-      None => Specifier::Unsupported(raw.to_string()),
+    Specifier::Latest(Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
+      semver_range: SemverRange::Any,
+    })
+  }
+
+  #[cfg(test)]
+  pub fn create_test(raw: &str) -> Self {
+    Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
+      semver_range: SemverRange::Any,
     }
   }
+
+  pub fn get_node_version(&self) -> Rc<node_semver::Version> {
+    self
+      .node_version
+      .get_or_init(|| {
+        let huge = HUGE.to_string();
+        let huge_version = format!("{huge}.{huge}.{huge}");
+        Specifier::new_node_version(&huge_version).expect("HUGE version is always valid")
+      })
+      .clone()
+  }
 }
diff --git a/crates/syncpack-specifier/src/lib.rs b/crates/syncpack-specifier/src/lib.rs
@@ -387,12 +387,12 @@ impl Specifier {
       Self::Alias(s) => s.inner_specifier.get_node_version(),
       Self::Git(s) => s.node_version.clone(),
       Self::Exact(s) => Some(s.node_version.clone()),
-      Self::Latest(s) => Some(s.node_version.clone()),
-      Self::Major(s) => Some(s.node_version.clone()),
-      Self::Minor(s) => Some(s.node_version.clone()),
+      Self::Latest(s) => Some(s.get_node_version()),
+      Self::Major(s) => Some(s.get_node_version()),
+      Self::Minor(s) => Some(s.get_node_version()),
       Self::Range(s) => Some(s.node_version.clone()),
-      Self::RangeMajor(s) => Some(s.node_version.clone()),
-      Self::RangeMinor(s) => Some(s.node_version.clone()),
+      Self::RangeMajor(s) => Some(s.get_node_version()),
+      Self::RangeMinor(s) => Some(s.get_node_version()),
       Self::WorkspaceProtocol(s) => s.as_resolved().and_then(|spec: &Rc<Specifier>| spec.get_node_version()),
       Self::Catalog(_)
       | Self::ComplexSemver(_)
@@ -418,8 +418,8 @@ impl Specifier {
       Self::ComplexSemver(s) => Some(s.node_range.clone()),
       Self::Git(s) => s.node_range.clone(),
       Self::Range(s) => Some(s.node_range.clone()),
-      Self::RangeMajor(s) => Some(s.node_range.clone()),
-      Self::RangeMinor(s) => Some(s.node_range.clone()),
+      Self::RangeMajor(s) => Some(s.get_node_range()),
+      Self::RangeMinor(s) => Some(s.get_node_range()),
       Self::WorkspaceProtocol(s) => {
         // Try resolved specifier first, otherwise check for "*" (RangeOnly(Any))
         s.as_resolved().and_then(|spec: &Rc<Specifier>| spec.get_node_range()).or_else(|| {
diff --git a/crates/syncpack-specifier/src/major.rs b/crates/syncpack-specifier/src/major.rs
@@ -1,27 +1,45 @@
 use {
   crate::{Specifier, HUGE},
-  std::rc::Rc,
+  std::{cell::OnceCell, rc::Rc},
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Major {
   /// "1"
   pub raw: String,
-  /// Used for ordering and comparison
-  ///
-  /// "1" -> "1.999999.999999"
-  pub node_version: Rc<node_semver::Version>,
+  /// Lazily parsed padded version: "1" -> "1.999999.999999"
+  node_version: OnceCell<Rc<node_semver::Version>>,
+}
+
+impl PartialEq for Major {
+  fn eq(&self, other: &Self) -> bool {
+    self.raw == other.raw
+  }
 }
 
 impl Major {
   pub fn create(raw: &str) -> Specifier {
-    let padded = format!("{}.{}.{}", raw, HUGE, HUGE);
-    match Specifier::new_node_version(&padded) {
-      Some(node_version) => Specifier::Major(Self {
-        raw: raw.to_string(),
-        node_version,
-      }),
-      None => Specifier::Unsupported(raw.to_string()),
+    Specifier::Major(Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
+    })
+  }
+
+  #[cfg(test)]
+  pub fn create_test(raw: &str) -> Self {
+    Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
     }
   }
+
+  pub fn get_node_version(&self) -> Rc<node_semver::Version> {
+    self
+      .node_version
+      .get_or_init(|| {
+        let padded = format!("{}.{}.{}", self.raw, HUGE, HUGE);
+        Specifier::new_node_version(&padded).expect("pre-validated major version")
+      })
+      .clone()
+  }
 }
diff --git a/crates/syncpack-specifier/src/minor.rs b/crates/syncpack-specifier/src/minor.rs
@@ -1,27 +1,45 @@
 use {
   crate::{Specifier, HUGE},
-  std::rc::Rc,
+  std::{cell::OnceCell, rc::Rc},
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Minor {
   /// "1.2"
   pub raw: String,
-  /// Used for ordering and comparison
-  ///
-  /// "1.2" -> "1.2.999999"
-  pub node_version: Rc<node_semver::Version>,
+  /// Lazily parsed padded version: "1.2" -> "1.2.999999"
+  node_version: OnceCell<Rc<node_semver::Version>>,
+}
+
+impl PartialEq for Minor {
+  fn eq(&self, other: &Self) -> bool {
+    self.raw == other.raw
+  }
 }
 
 impl Minor {
   pub fn create(raw: &str) -> Specifier {
-    let padded = format!("{}.{}", raw, HUGE);
-    match Specifier::new_node_version(&padded) {
-      Some(node_version) => Specifier::Minor(Self {
-        raw: raw.to_string(),
-        node_version,
-      }),
-      None => Specifier::Unsupported(raw.to_string()),
+    Specifier::Minor(Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
+    })
+  }
+
+  #[cfg(test)]
+  pub fn create_test(raw: &str) -> Self {
+    Self {
+      raw: raw.to_string(),
+      node_version: OnceCell::new(),
     }
   }
+
+  pub fn get_node_version(&self) -> Rc<node_semver::Version> {
+    self
+      .node_version
+      .get_or_init(|| {
+        let padded = format!("{}.{}", self.raw, HUGE);
+        Specifier::new_node_version(&padded).expect("pre-validated minor version")
+      })
+      .clone()
+  }
 }
diff --git a/crates/syncpack-specifier/src/range_major.rs b/crates/syncpack-specifier/src/range_major.rs
@@ -1,47 +1,72 @@
 use {
   crate::{semver_range::SemverRange, strip_semver_range, Specifier, HUGE},
-  std::rc::Rc,
+  std::{cell::OnceCell, rc::Rc},
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RangeMajor {
   /// "^1"
   pub raw: String,
-  /// Used when checking if specifiers satisfy each other
-  ///
-  /// - "^1.999999.999999"
-  pub node_range: Rc<node_semver::Range>,
-  /// Used for ordering and comparison, semver range characters are NOT
-  /// included
-  ///
-  /// - "^1" → "1.999999.999999"
-  pub node_version: Rc<node_semver::Version>,
-  /// The raw semver specifier without range characters
-  ///
-  /// "1"
+  /// Lazily parsed range: "^1.999999.999999"
+  node_range: OnceCell<Rc<node_semver::Range>>,
+  /// Lazily parsed padded version: "1.999999.999999"
+  node_version: OnceCell<Rc<node_semver::Version>>,
+  /// The raw semver specifier without range characters: "1"
   pub semver_number: String,
   /// The semver range characters used in this specifier
-  ///
-  /// `SemverRange::Minor`
   pub semver_range: SemverRange,
 }
 
+impl PartialEq for RangeMajor {
+  fn eq(&self, other: &Self) -> bool {
+    self.raw == other.raw
+  }
+}
+
 impl RangeMajor {
   pub fn create(raw: &str) -> Specifier {
     let semver_range = SemverRange::parse(raw);
     let semver_number = strip_semver_range(raw).to_string();
-    let padded = format!("{}.{}.{}", semver_number, HUGE, HUGE);
-    let range_str = format!("{}{}", semver_range.unwrap(), padded);
+    Specifier::RangeMajor(Self {
+      raw: raw.to_string(),
+      node_range: OnceCell::new(),
+      node_version: OnceCell::new(),
+      semver_number,
+      semver_range,
+    })
+  }
 
-    match (Specifier::new_node_version(&padded), Specifier::new_node_range(&range_str)) {
-      (Some(node_version), Some(node_range)) => Specifier::RangeMajor(Self {
-        raw: raw.to_string(),
-        node_range,
-        node_version,
-        semver_number,
-        semver_range,
-      }),
-      _ => Specifier::Unsupported(raw.to_string()),
+  #[cfg(test)]
+  pub fn create_test(raw: &str) -> Self {
+    let semver_range = SemverRange::parse(raw);
+    let semver_number = strip_semver_range(raw).to_string();
+    Self {
+      raw: raw.to_string(),
+      node_range: OnceCell::new(),
+      node_version: OnceCell::new(),
+      semver_number,
+      semver_range,
     }
   }
+
+  pub fn get_node_version(&self) -> Rc<node_semver::Version> {
+    self
+      .node_version
+      .get_or_init(|| {
+        let padded = format!("{}.{}.{}", self.semver_number, HUGE, HUGE);
+        Specifier::new_node_version(&padded).expect("pre-validated range major version")
+      })
+      .clone()
+  }
+
+  pub fn get_node_range(&self) -> Rc<node_semver::Range> {
+    self
+      .node_range
+      .get_or_init(|| {
+        let padded = format!("{}.{}.{}", self.semver_number, HUGE, HUGE);
+        let range_str = format!("{}{}", self.semver_range.unwrap(), padded);
+        Specifier::new_node_range(&range_str).expect("pre-validated range major")
+      })
+      .clone()
+  }
 }
diff --git a/crates/syncpack-specifier/src/range_minor.rs b/crates/syncpack-specifier/src/range_minor.rs
diff --git a/crates/syncpack-specifier/src/test_faker.rs b/crates/syncpack-specifier/src/test_faker.rs
