rubydex 0.2.9 → 0.3.0

data/rust/rubydex/src/main.rs

@@ -1,13 +1,9 @@
 use clap::{Parser, ValueEnum};
-use std::{
-    fs, mem,
-    path::{Path, PathBuf},
-    time::{Duration, Instant},
-};
+use std::{fs, mem, path::PathBuf};
 
 use rubydex::{
     dot,
-    indexing::{self, IndexerBackend, LanguageId, build_local_graph},
+    indexing::{self, IndexerBackend},
     integrity, listing,
     model::graph::Graph,
     resolution::Resolver,
@@ -16,7 +12,6 @@ use rubydex::{
         timer::{Timer, time_it},
     },
 };
-use url::Url;
 
 #[derive(Parser, Debug)]
 #[command(name = "rubydex_cli", about = "A Static Analysis Toolkit for Ruby", version)]
@@ -61,21 +56,6 @@ struct Args {
         help = "Write orphan definitions report to specified file"
     )]
     report_orphans: Option<String>,
-
-    #[arg(
-        long = "incremental_cycle",
-        value_name = "N",
-        help = "After the initial build, run N incremental resolution cycles and report their timings"
-    )]
-    incremental_cycle: Option<usize>,
-
-    #[arg(
-        long = "incremental_files",
-        value_name = "N",
-        default_value_t = 1,
-        help = "Number of files to re-index per incremental cycle"
-    )]
-    incremental_files: usize,
 }
 
 #[derive(Debug, Clone, ValueEnum)]
@@ -149,14 +129,6 @@ fn main() {
 
     let backend = IndexerBackend::from(&args.indexer);
 
-    // The incremental benchmark re-indexes files after the initial build, so keep a copy of the
-    // paths before `index_files` consumes them.
-    let incremental_paths = if args.incremental_cycle.is_some() {
-        file_paths.clone()
-    } else {
-        Vec::new()
-    };
-
     let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths, backend) });
 
     for error in errors {
@@ -174,12 +146,6 @@ fn main() {
         resolver.resolve();
     });
 
-    // Incremental resolution benchmark. Runs before the stop-after check so it can be combined with
-    // `--stop-after=resolution`.
-    if let Some(cycles) = args.incremental_cycle {
-        run_incremental_resolution(&mut graph, &incremental_paths, cycles, args.incremental_files, backend);
-    }
-
     if let Some(StopAfter::Resolution) = args.stop_after {
         return exit(args.stats);
     }
@@ -241,91 +207,3 @@ fn main() {
     // Forget the graph so we don't have to wait for deallocation and let the system reclaim the memory at exit
     mem::forget(graph);
 }
-
-/// Simulates incremental editing to measure incremental resolution cost. For each cycle it
-/// re-indexes a rotating window of `files_per_cycle` files (parsing plus the same invalidation the
-/// LSP performs on save) and then re-runs resolution over the resulting pending work, reporting
-/// per-cycle and aggregate `resolve()` timings.
-///
-/// With `--stats`, the `compute_descendants` breakdown printed in the timing summary reflects the
-/// last incremental cycle, since it is recorded on every `resolve()`.
-fn run_incremental_resolution(
-    graph: &mut Graph,
-    paths: &[PathBuf],
-    cycles: usize,
-    files_per_cycle: usize,
-    backend: IndexerBackend,
-) {
-    if paths.is_empty() || cycles == 0 || files_per_cycle == 0 {
-        eprintln!("Skipping incremental resolution: nothing to re-index");
-        return;
-    }
-
-    let files_per_cycle = files_per_cycle.min(paths.len());
-
-    let mut reindex_total = Duration::ZERO;
-    let mut resolve_total = Duration::ZERO;
-    let mut resolve_min = Duration::MAX;
-    let mut resolve_max = Duration::ZERO;
-
-    println!();
-    println!("Incremental resolution ({cycles} cycle(s), {files_per_cycle} file(s)/cycle)");
-    println!("  Scenario: no-op reindex; files are indexed again without changing their contents.");
-    println!("  This should be the fastest incremental resolution path.");
-    println!("  Add scenario-based benchmarks before optimizing incremental resolution.");
-
-    for cycle in 0..cycles {
-        // Re-index the window of files for this cycle. Rotating the window across cycles samples
-        // different parts of the codebase rather than measuring the same delta repeatedly.
-        let reindex_start = Instant::now();
-        for i in 0..files_per_cycle {
-            let path = &paths[(cycle * files_per_cycle + i) % paths.len()];
-            reindex_file(graph, path, backend);
-        }
-        reindex_total += reindex_start.elapsed();
-
-        let resolve_start = Instant::now();
-        Resolver::new(graph).resolve();
-        let elapsed = resolve_start.elapsed();
-
-        resolve_total += elapsed;
-        resolve_min = resolve_min.min(elapsed);
-        resolve_max = resolve_max.max(elapsed);
-
-        println!(
-            "  cycle {:>3}: resolve {:9.3}ms",
-            cycle + 1,
-            elapsed.as_secs_f64() * 1000.0
-        );
-    }
-
-    let avg = resolve_total / u32::try_from(cycles).expect("cycle count fits in u32");
-
-    println!(
-        "  resolve total {:.3}ms  avg {:.3}ms  min {:.3}ms  max {:.3}ms",
-        resolve_total.as_secs_f64() * 1000.0,
-        avg.as_secs_f64() * 1000.0,
-        resolve_min.as_secs_f64() * 1000.0,
-        resolve_max.as_secs_f64() * 1000.0,
-    );
-    println!(
-        "  reindex+invalidate total {:.3}ms (parse + document merge, excluded from resolve above)",
-        reindex_total.as_secs_f64() * 1000.0,
-    );
-}
-
-/// Re-indexes a single file into the graph, running the same invalidation the LSP performs on save.
-fn reindex_file(graph: &mut Graph, path: &Path, backend: IndexerBackend) {
-    let Ok(source) = fs::read_to_string(path) else {
-        eprintln!("Failed to read file `{}`", path.display());
-        return;
-    };
-    let Ok(url) = Url::from_file_path(path) else {
-        eprintln!("Couldn't build URI from path `{}`", path.display());
-        return;
-    };
-
-    let language = path.extension().map_or(LanguageId::Ruby, LanguageId::from);
-    let local_graph = build_local_graph(url.to_string(), &source, &language, backend);
-    graph.consume_document_changes(local_graph);
-}

data/rust/rubydex/src/model/declaration.rs

@@ -192,10 +192,6 @@ macro_rules! namespace_declaration {
                 &self.ancestors
             }
 
-            pub fn ancestors_mut(&mut self) -> &mut Ancestors {
-                &mut self.ancestors
-            }
-
             #[must_use]
             pub fn clone_ancestors(&self) -> Ancestors {
                 self.ancestors.clone()
@@ -552,13 +548,6 @@ impl Namespace {
         all_namespaces!(self, it => it.remove_descendant(descendant_id));
     }
 
-    pub fn for_each_ancestor<F>(&self, mut f: F)
-    where
-        F: FnMut(&Ancestor),
-    {
-        all_namespaces!(self, it => it.ancestors().iter().for_each(&mut f));
-    }
-
     pub fn for_each_descendant<F>(&self, mut f: F)
     where
         F: FnMut(&DeclarationId),

data/rust/rubydex/src/model/definitions.rs

@@ -29,6 +29,7 @@ use crate::{
     assert_mem_size,
     model::{
         comment::Comment,
+        id::id_from_parts,
         ids::{self, ConstantReferenceId, DefinitionId, NameId, StringId, UriId},
         visibility::Visibility,
     },
@@ -673,13 +674,13 @@ impl ConstantAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.alias_constant.uri_id(),
+        id_from_parts!(
+            DefinitionId;
+            self.alias_constant.uri_id().get(),
             self.alias_constant.offset().start(),
-            *self.alias_constant.name_id(),
-            *self.target_name_id,
-        ))
+            self.alias_constant.name_id().get(),
+            self.target_name_id.get(),
+        )
     }
 
     #[must_use]
@@ -757,7 +758,7 @@ impl ConstantVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.target))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.target.get())
     }
 
     #[must_use]
@@ -837,7 +838,7 @@ impl MethodVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get(), self.flags.bits())
     }
 
     #[must_use]
@@ -1123,7 +1124,7 @@ impl AttrAccessorDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1204,7 +1205,7 @@ impl AttrReaderDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1285,7 +1286,7 @@ impl AttrWriterDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1363,7 +1364,7 @@ impl GlobalVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1436,7 +1437,7 @@ impl InstanceVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1509,7 +1510,7 @@ impl ClassVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1583,13 +1584,13 @@ impl MethodAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.uri_id,
+        id_from_parts!(
+            DefinitionId;
+            self.uri_id.get(),
             self.offset.start(),
-            *self.new_name_str_id,
-            *self.old_name_str_id,
-        ))
+            self.new_name_str_id.get(),
+            self.old_name_str_id.get(),
+        )
     }
 
     #[must_use]
@@ -1669,13 +1670,13 @@ impl GlobalVariableAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.uri_id,
+        id_from_parts!(
+            DefinitionId;
+            self.uri_id.get(),
             self.offset.start(),
-            *self.new_name_str_id,
-            *self.old_name_str_id,
-        ))
+            self.new_name_str_id.get(),
+            self.old_name_str_id.get(),
+        )
     }
 
     #[must_use]

data/rust/rubydex/src/model/document.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use line_index::LineIndex;
 use url::Url;
+use xxhash_rust::xxh3::xxh3_64;
 
 use crate::assert_mem_size;
 use crate::diagnostic::Diagnostic;
@@ -17,8 +18,9 @@ pub struct Document {
     method_reference_ids: Vec<MethodReferenceId>,
     constant_reference_ids: Vec<ConstantReferenceId>,
     diagnostics: Vec<Diagnostic>,
+    content_hash: u64,
 }
-assert_mem_size!(Document, 176);
+assert_mem_size!(Document, 184);
 
 impl Document {
     #[must_use]
@@ -30,6 +32,7 @@ impl Document {
             method_reference_ids: Vec::new(),
             constant_reference_ids: Vec::new(),
             diagnostics: Vec::new(),
+            content_hash: xxh3_64(source.as_bytes()),
         }
     }
 
@@ -38,6 +41,11 @@ impl Document {
         &self.uri
     }
 
+    #[must_use]
+    pub fn content_hash(&self) -> u64 {
+        self.content_hash
+    }
+
     #[must_use]
     pub fn line_index(&self) -> &LineIndex {
         &self.line_index
@@ -84,6 +92,39 @@ impl Document {
         self.diagnostics.push(diagnostic);
     }
 
+    /// The file-system path of this document, decoded from its URI.
+    ///
+    /// Returns `None` when the URI is not a `file://` URL (e.g. the synthetic built-in document) or
+    /// cannot be converted to a path. Uses `Url` so percent-encoding and platform-specific paths
+    /// (including Windows drive paths) are handled correctly.
+    #[must_use]
+    pub fn file_path(&self) -> Option<PathBuf> {
+        let url = Url::parse(&self.uri).ok()?;
+        if url.scheme() != "file" {
+            return None;
+        }
+        url.to_file_path().ok()
+    }
+
+    /// The base file name of this document (the last path segment), decoded from its URI.
+    ///
+    /// Prefers the platform file path, but falls back to the last URL path segment so it still works
+    /// for `file://` URIs that don't convert to a local path on the current platform (e.g. a
+    /// drive-less path like `file:///foo.rb` on Windows). Returns `None` only when the URI has no
+    /// usable path segment (e.g. the synthetic built-in document).
+    #[must_use]
+    pub fn file_name(&self) -> Option<String> {
+        if let Some(path) = self.file_path()
+            && let Some(name) = path.file_name()
+        {
+            return Some(name.to_string_lossy().into_owned());
+        }
+
+        let url = Url::parse(&self.uri).ok()?;
+        let segment = url.path_segments()?.rfind(|segment| !segment.is_empty())?;
+        Some(segment.to_string())
+    }
+
     /// Computes the require path for this document given load paths.
     ///
     /// Returns `None` if:
@@ -97,12 +138,7 @@ impl Document {
     /// Panics if load path entries exceed u16.
     #[must_use]
     pub fn require_path(&self, load_paths: &[PathBuf]) -> Option<(String, u16)> {
-        let url = Url::parse(&self.uri).ok()?;
-        if url.scheme() != "file" {
-            return None;
-        }
-
-        let file_path = url.to_file_path().ok()?;
+        let file_path = self.file_path()?;
         if file_path.extension().is_none_or(|ext| ext != "rb") {
             return None;
         }

data/rust/rubydex/src/model/graph.rs

@@ -2,7 +2,6 @@ use std::collections::HashSet;
 use std::collections::hash_map::Entry;
 use std::path::{Path, PathBuf};
 
-use crate::assert_mem_size;
 use crate::config::Config;
 use crate::diagnostic::Diagnostic;
 use crate::errors::Errors;
@@ -21,6 +20,7 @@ use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
 use crate::model::visibility::Visibility;
+use crate::{assert_mem_size, assert_send_sync};
 use crate::{query, stats};
 
 /// An entity whose validity depends on a particular `NameId`.
@@ -94,6 +94,7 @@ pub struct Graph {
     config: Config,
 }
 assert_mem_size!(Graph, 352);
+assert_send_sync!(Graph);
 
 impl Graph {
     #[must_use]
@@ -554,31 +555,6 @@ impl Graph {
         name_id
     }
 
-    /// Searches for the initial attached object for an arbitrarily nested singleton class.
-    /// Walks up the owner chain until finding a non-singleton namespace.
-    ///
-    /// # Example
-    /// For `Foo::<Foo>::<<Foo>>`, returns `Foo`
-    ///
-    /// # Panics
-    ///
-    /// Panics if we attached a singleton class to something that isn't a namespace
-    #[must_use]
-    pub fn attached_object<'a>(&'a self, maybe_singleton: &'a Namespace) -> &'a Namespace {
-        let mut attached_object = maybe_singleton;
-
-        while matches!(attached_object, Namespace::SingletonClass(_)) {
-            attached_object = self
-                .declarations
-                .get(attached_object.owner_id())
-                .unwrap()
-                .as_namespace()
-                .unwrap();
-        }
-
-        attached_object
-    }
-
     #[must_use]
     pub fn get(&self, name: &str) -> Option<Vec<&Definition>> {
         let declaration_id = declaration_id_from_lookup_name(name);
@@ -676,6 +652,9 @@ impl Graph {
     ///
     /// For methods, the latest definition wins. For constants, the latest
     /// `private_constant`/`public_constant` wins, otherwise `Public`.
+    ///
+    /// Methods declared via `module_function :bar` return `Private` on the instance
+    /// side (`Foo#bar`) and `Public` on the singleton side (`Foo::<Foo>#bar`).
     #[must_use]
     pub fn visibility(&self, declaration_id: &DeclarationId) -> Option<Visibility> {
         let declaration = self.declarations.get(declaration_id)?;
@@ -701,7 +680,13 @@ impl Graph {
                     };
 
                     let visibility = match definition {
-                        Definition::MethodVisibility(vis) => Some(*vis.visibility()),
+                        Definition::MethodVisibility(vis) => match *vis.visibility() {
+                            Visibility::ModuleFunction if vis.flags().is_singleton_method_visibility() => {
+                                Some(Visibility::Public)
+                            }
+                            Visibility::ModuleFunction => Some(Visibility::Private),
+                            other => Some(other),
+                        },
                         Definition::Method(method) => Some(*method.visibility()),
                         Definition::AttrAccessor(attr) => Some(*attr.visibility()),
                         Definition::AttrReader(attr) => Some(*attr.visibility()),
@@ -1044,7 +1029,17 @@ impl Graph {
     /// 3. `extend` -- merges the new `LocalGraph` into the now-clean graph
     pub fn consume_document_changes(&mut self, other: LocalGraph) {
         let uri_id = other.uri_id();
-        let old_document = self.documents.remove(&uri_id);
+
+        let old_document = match self.documents.entry(uri_id) {
+            Entry::Occupied(entry) => {
+                // No changes to the document, skip invalidation and merging
+                if entry.get().content_hash() == other.document().content_hash() {
+                    return;
+                }
+                Some(entry.remove())
+            }
+            Entry::Vacant(_) => None,
+        };
 
         // Skip invalidation during boot indexing (no documents have been resolved yet)
         // or when the document is brand new (no old data to invalidate against).
@@ -4209,4 +4204,21 @@ mod incremental_resolution_tests {
             );
         }
     }
+
+    #[test]
+    fn unchanged_document_does_not_trigger_invalidation() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///a.rb", "class Foo; end");
+        context.resolve();
+
+        // Re-indexing the same content should not trigger any invalidation or changes
+        context.index_uri("file:///a.rb", "class Foo; end");
+
+        let mut graph = context.into_graph();
+
+        assert!(
+            graph.take_pending_work().is_empty(),
+            "Graph should have no pending work after re-indexing unchanged document"
+        );
+    }
 } // mod incremental_resolution_tests

data/rust/rubydex/src/model/id.rs

@@ -1,6 +1,14 @@
 use std::{marker::PhantomData, num::NonZeroU64, ops::Deref};
 use xxhash_rust::xxh3;
 
+/// Creates an ID by hashing fixed-width integer components in little-endian order.
+macro_rules! id_from_parts {
+    ($id:ty; $($part:expr),+ $(,)?) => {
+        <$id>::from([$(($part).to_le_bytes().as_slice()),+])
+    };
+}
+pub(crate) use id_from_parts;
+
 /// Maps a u64 hash to a `NonZeroU64` by replacing 0 with `u64::MAX`.
 /// The probability of a 64-bit hash being exactly 0 is 2^-64 (~5.4e-20),
 /// and remapping 0 → MAX just means those two inputs collide — the same
@@ -70,6 +78,18 @@ impl<T> From<&String> for Id<T> {
     }
 }
 
+impl<T, const N: usize> From<[&[u8]; N]> for Id<T> {
+    fn from(parts: [&[u8]; N]) -> Self {
+        let mut hasher = xxh3::Xxh3Default::new();
+
+        for part in parts {
+            hasher.update(part);
+        }
+
+        Self::new(hasher.digest())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -78,6 +98,41 @@ mod tests {
     pub struct Marker;
     pub type TestId = Id<Marker>;
 
+    #[test]
+    fn from_byte_slices_matches_concatenated_string() {
+        assert_eq!(
+            TestId::from("foobar"),
+            TestId::from([b"foo".as_slice(), b"bar".as_slice()]),
+        );
+    }
+
+    #[test]
+    fn from_parts_matches_mixed_width_byte_slices() {
+        let id = 42_u64;
+        let offset = 7_u32;
+        let tag = 2_u8;
+
+        assert_eq!(
+            TestId::from([
+                id.to_le_bytes().as_slice(),
+                offset.to_le_bytes().as_slice(),
+                tag.to_le_bytes().as_slice(),
+            ]),
+            id_from_parts!(TestId; id, offset, tag),
+        );
+    }
+
+    #[test]
+    fn from_byte_slices_is_deterministic() {
+        let parts: [&[u8]; 2] = [&[1, 2, 3], &[4, 5]];
+        assert_eq!(TestId::from(parts), TestId::from(parts));
+    }
+
+    #[test]
+    fn from_byte_slices_distinguishes_inputs() {
+        assert_ne!(TestId::from([b"foo".as_slice()]), TestId::from([b"bar".as_slice()]),);
+    }
+
     #[test]
     fn test_create_hash() {
         // Same input should produce same hash (deterministic)

data/rust/rubydex/src/model/ids.rs

@@ -1,6 +1,9 @@
 use crate::{
     assert_mem_size,
-    model::{definitions::Receiver, id::Id},
+    model::{
+        definitions::Receiver,
+        id::{Id, id_from_parts},
+    },
     offset::Offset,
 };
 
@@ -27,7 +30,7 @@ assert_mem_size!(DefinitionId, 8);
 
 #[must_use]
 pub fn namespace_definition_id(uri_id: UriId, offset: &Offset, name_id: NameId) -> DefinitionId {
-    DefinitionId::from(&format!("{}{}{}", *uri_id, offset.start(), *name_id))
+    id_from_parts!(DefinitionId; uri_id.get(), offset.start(), name_id.get())
 }
 
 #[must_use]
@@ -37,14 +40,23 @@ pub fn method_definition_id(
     str_id: StringId,
     receiver: Option<&Receiver>,
 ) -> DefinitionId {
-    let mut formatted_id = format!("{}{}{}", *uri_id, offset.start(), *str_id);
-    if let Some(receiver) = receiver {
-        match receiver {
-            Receiver::SelfReceiver(def_id) => formatted_id.push_str(&def_id.to_string()),
-            Receiver::ConstantReceiver(name_id) => formatted_id.push_str(&name_id.to_string()),
-        }
+    match receiver {
+        Some(Receiver::SelfReceiver(def_id)) => id_from_parts!(
+            DefinitionId;
+            uri_id.get(),
+            offset.start(),
+            str_id.get(),
+            def_id.get(),
+        ),
+        Some(Receiver::ConstantReceiver(name_id)) => id_from_parts!(
+            DefinitionId;
+            uri_id.get(),
+            offset.start(),
+            str_id.get(),
+            name_id.get(),
+        ),
+        None => id_from_parts!(DefinitionId; uri_id.get(), offset.start(), str_id.get()),
     }
-    DefinitionId::from(&formatted_id)
 }
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]