rubydex 0.2.4-aarch64-linux → 0.2.5-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49147264143f618ef7d2b5bbfa983e511b86123dc01548c2a4176e686a44b57e
-  data.tar.gz: cbd51f1380330f85dde7861c7df96cbc1db4117458952c561164eef9c511901e
+  metadata.gz: 96c428371246628899d384b7e650919ee41c9eaa42413af5244175c9972fb44b
+  data.tar.gz: 702b06d961ffdd5da12dcb7eb074f83b4d2bc30d3e06bc29a4749a39d0501d58
 SHA512:
-  metadata.gz: 5daa009adaef78d504f2710aac72ec36875a3a7ae169048b36e7220d984ddaf7dd562431a460a44b95530bb030a341887ccf300d14646051f722ba0cc941e9bb
-  data.tar.gz: adf4c9a9faf405356b64e6de927a7aa4b8499164c9cf48918683b45ab0e7825668f5505d50e0b29305292bae3db511ae6ffb6ab2e96628c1b1ecdc2076fb8b3b
+  metadata.gz: d9aed2a16df08353c7b66d1dbfb652746f2241c4c6782fb714d89c4ae9b64487e552c5f0b418bfd36b6d01a1477f2cc445e8be68ce0083501edad77220f9b8f8
+  data.tar.gz: c6f95989ccb6da1bed31659e052f5b83ac8b2870c24d2ca59ac10003b60dc199cba778e0f67188f58389f6dd7fddae295ded50b3ad1f9e4fbb2b720526a2ccd9

data/exe/rubydex_mcp

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+
+host_os = RbConfig::CONFIG.fetch("host_os")
+executable = host_os.match?(/mswin|mingw|cygwin/) ? "rubydex_mcp.exe" : "rubydex_mcp"
+binary = File.expand_path("../lib/rubydex/bin/#{executable}", __dir__)
+
+unless File.executable?(binary)
+  abort(<<~MESSAGE.chomp)
+    rubydex_mcp is not available at #{binary}.
+    Install a precompiled rubydex gem, or reinstall rubydex with Cargo available so the MCP executable can be built locally.
+  MESSAGE
+end
+
+exec(binary, *ARGV)

data/ext/rubydex/definition.c

@@ -195,6 +195,60 @@ static VALUE rdxr_definition_declaration(VALUE self) {
     return rb_class_new_instance(2, argv, decl_class);
 }
 
+static VALUE rdxi_build_definition(VALUE graph_obj, void *graph, uint64_t definition_id) {
+    DefinitionKind kind = rdx_definition_kind(graph, definition_id);
+    VALUE defn_class = rdxi_definition_class_for_kind(kind);
+    VALUE argv[] = {graph_obj, ULL2NUM(definition_id)};
+
+    return rb_class_new_instance(2, argv, defn_class);
+}
+
+// Definition#lexical_owner -> Rubydex::Definition?
+// Returns the lexically enclosing definition, if any.
+static VALUE rdxr_definition_lexical_owner(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const uint64_t *owner_id = rdx_definition_lexical_nesting_id(graph, data->id);
+    if (owner_id == NULL) {
+        return Qnil;
+    }
+
+    VALUE owner = rdxi_build_definition(data->graph_obj, graph, *owner_id);
+    free_u64(owner_id);
+
+    return owner;
+}
+
+// Definition#lexical_nesting -> Array<Rubydex::Definition>
+// Returns the lexical nesting from the direct owner up to the root.
+static VALUE rdxr_definition_lexical_nesting(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    VALUE nesting = rb_ary_new();
+    uint64_t definition_id = data->id;
+
+    while (true) {
+        const uint64_t *owner_id = rdx_definition_lexical_nesting_id(graph, definition_id);
+        if (owner_id == NULL) {
+            break;
+        }
+
+        rb_ary_push(nesting, rdxi_build_definition(data->graph_obj, graph, *owner_id));
+        definition_id = *owner_id;
+        free_u64(owner_id);
+    }
+
+    return nesting;
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -306,6 +360,8 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
     rb_define_method(cDefinition, "declaration", rdxr_definition_declaration, 0);
+    rb_define_method(cDefinition, "lexical_owner", rdxr_definition_lexical_owner, 0);
+    rb_define_method(cDefinition, "lexical_nesting", rdxr_definition_lexical_nesting, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);

data/ext/rubydex/extconf.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mkmf"
+require "fileutils"
 require "pathname"
 
 unless system("cargo", "--version", out: File::NULL, err: File::NULL)
@@ -81,6 +82,12 @@ else
 end
 
 lib_dir = gem_dir.join("lib").join("rubydex")
+mcp_bin_dir = lib_dir.join("bin")
+FileUtils.mkdir_p(mcp_bin_dir)
+
+mcp_executable = Gem.win_platform? ? "rubydex_mcp.exe" : "rubydex_mcp"
+mcp_src = target_dir.join(mcp_executable)
+mcp_dst = mcp_bin_dir.join(mcp_executable)
 
 copy_dylib_commands = if Gem.win_platform?
   ""
@@ -107,6 +114,7 @@ new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.cho
   .rust_built: $(RUST_SRCS)
   \t#{cargo_command} || (echo "Compiling Rust failed" && exit 1)
   \t$(COPY) #{bindings_path} #{__dir__}
+  \t$(COPY) #{mcp_src} #{mcp_dst}
   \ttouch $@
 
   compile_rust: .rust_built

data/lib/rubydex/declaration.rb

@@ -21,9 +21,9 @@ module Rubydex
   end
 
   class Namespace < Declaration
-    #: (String ancestor_name) -> bool
-    def has_ancestor?(ancestor_name)
-      ancestors.any? { |ancestor| ancestor.name == ancestor_name }
+    #: (*String ancestor_names) -> bool
+    def has_ancestor?(*ancestor_names)
+      ancestors.any? { |ancestor| ancestor_names.include?(ancestor.name) }
     end
   end
 

data/lib/rubydex/graph.rb

@@ -17,6 +17,8 @@ module Rubydex
       "tmp",
     ].freeze
 
+    INDEXABLE_EXTENSIONS = [".rb", ".rake", ".rbs", ".ru"].freeze
+
     #: String
     attr_accessor :workspace_path
 
@@ -45,7 +47,7 @@ module Rubydex
 
         if File.directory?(full_path)
           paths << full_path unless IGNORED_DIRECTORIES.include?(entry)
-        elsif File.extname(entry) == ".rb"
+        elsif INDEXABLE_EXTENSIONS.include?(File.extname(entry))
           paths << full_path
         end
       end

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/rbi/rubydex.rbi

@@ -104,8 +104,8 @@ class Rubydex::Namespace < Rubydex::Declaration
   sig { returns(T::Enumerable[Rubydex::Namespace]) }
   def ancestors; end
 
-  sig { params(ancestor_name: String).returns(T::Boolean) }
-  def has_ancestor?(ancestor_name); end
+  sig { params(ancestor_names: String).returns(T::Boolean) }
+  def has_ancestor?(*ancestor_names); end
 
   sig { returns(T::Enumerable[Rubydex::Namespace]) }
   def descendants; end
@@ -152,6 +152,12 @@ class Rubydex::Definition
   sig { returns(T.nilable(Rubydex::Declaration)) }
   def declaration; end
 
+  sig { returns(T.nilable(Rubydex::Definition)) }
+  def lexical_owner; end
+
+  sig { returns(T::Array[Rubydex::Definition]) }
+  def lexical_nesting; end
+
   class << self
     private
 

data/rust/rubydex/src/indexing/local_graph.rs

@@ -206,6 +206,44 @@ impl LocalGraph {
         &self.name_dependents
     }
 
+    /// Creates a `LocalGraph` from pre-built parts (used by the operation applier pipeline).
+    #[must_use]
+    pub fn from_parts(
+        uri_id: UriId,
+        document: Document,
+        strings: IdentityHashMap<StringId, StringRef>,
+        names: IdentityHashMap<NameId, NameRef>,
+    ) -> Self {
+        let mut name_dependents: IdentityHashMap<NameId, Vec<NameDependent>> = IdentityHashMap::default();
+        for (name_id, name_ref) in &names {
+            if let NameRef::Unresolved(name) = name_ref {
+                if let Some(&parent_scope) = name.parent_scope().as_ref() {
+                    name_dependents
+                        .entry(parent_scope)
+                        .or_default()
+                        .push(NameDependent::ChildName(*name_id));
+                }
+                if let Some(&nesting_id) = name.nesting().as_ref() {
+                    name_dependents
+                        .entry(nesting_id)
+                        .or_default()
+                        .push(NameDependent::NestedName(*name_id));
+                }
+            }
+        }
+
+        Self {
+            uri_id,
+            document,
+            definitions: IdentityHashMap::default(),
+            strings,
+            names,
+            constant_references: IdentityHashMap::default(),
+            method_references: IdentityHashMap::default(),
+            name_dependents,
+        }
+    }
+
     // Into parts
 
     #[must_use]

data/rust/rubydex/src/indexing/ruby_indexer.rs

@@ -2481,5 +2481,11 @@ impl Visit<'_> for RubyIndexer<'_> {
 }
 
 #[cfg(test)]
+fn backend() -> super::IndexerBackend {
+    super::IndexerBackend::RubyIndexer
+}
+
+#[cfg(test)]
+#[allow(clippy::duplicate_mod)]
 #[path = "ruby_indexer_tests.rs"]
 mod tests;

data/rust/rubydex/src/indexing/ruby_indexer_tests.rs

@@ -1,3 +1,7 @@
+// This file is included via #[path] by both ruby_indexer.rs and operation/applier.rs
+// to run the same tests against both indexing backends. Each parent module provides
+// a `backend()` function that `index_source` calls via `super::backend()`.
+
 use crate::{
     assert_def_comments_eq, assert_def_mixins_eq, assert_def_name_eq, assert_def_name_offset_eq, assert_def_str_eq,
     assert_def_superclass_ref_eq, assert_definition_at, assert_dependents, assert_local_diagnostics_eq,
@@ -86,7 +90,7 @@ macro_rules! assert_method_references_eq {
 }
 
 fn index_source(source: &str) -> LocalGraphTest {
-    LocalGraphTest::new("file:///foo.rb", source)
+    LocalGraphTest::new_with_backend("file:///foo.rb", source, super::backend())
 }
 
 mod constant_tests {

data/rust/rubydex/src/indexing.rs

@@ -3,6 +3,7 @@ use crate::{
     indexing::{local_graph::LocalGraph, rbs_indexer::RBSIndexer, ruby_indexer::RubyIndexer},
     job_queue::{Job, JobQueue},
     model::graph::Graph,
+    operation::ruby_builder::RubyOperationBuilder,
 };
 use crossbeam_channel::{Sender, unbounded};
 use std::{ffi::OsStr, fs, path::PathBuf, sync::Arc};
@@ -12,6 +13,15 @@ pub mod local_graph;
 pub mod rbs_indexer;
 pub mod ruby_indexer;
 
+/// Which backend to use for indexing Ruby files.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IndexerBackend {
+    /// The original tree-walking indexer.
+    RubyIndexer,
+    /// The two-phase operation builder + applier pipeline.
+    OperationBuilder,
+}
+
 /// The language of a source document, used to dispatch to the appropriate indexer
 pub enum LanguageId {
     Ruby,
@@ -42,15 +52,22 @@ impl LanguageId {
 /// Job that indexes a single file
 pub struct IndexingJob {
     path: PathBuf,
+    backend: IndexerBackend,
     local_graph_tx: Sender<LocalGraph>,
     errors_tx: Sender<Errors>,
 }
 
 impl IndexingJob {
     #[must_use]
-    pub fn new(path: PathBuf, local_graph_tx: Sender<LocalGraph>, errors_tx: Sender<Errors>) -> Self {
+    pub fn new(
+        path: PathBuf,
+        backend: IndexerBackend,
+        local_graph_tx: Sender<LocalGraph>,
+        errors_tx: Sender<Errors>,
+    ) -> Self {
         Self {
             path,
+            backend,
             local_graph_tx,
             errors_tx,
         }
@@ -84,7 +101,7 @@ impl Job for IndexingJob {
         };
 
         let language = self.path.extension().map_or(LanguageId::Ruby, LanguageId::from);
-        let local_graph = build_local_graph(url.to_string(), &source, &language);
+        let local_graph = build_local_graph(url.to_string(), &source, &language, self.backend);
 
         self.local_graph_tx
             .send(local_graph)
@@ -94,7 +111,7 @@ impl Job for IndexingJob {
 
 /// Indexes a single source string in memory, dispatching to the appropriate indexer based on `language_id`.
 pub fn index_source(graph: &mut Graph, uri: &str, source: &str, language_id: &LanguageId) {
-    let local_graph = build_local_graph(uri.to_string(), source, language_id);
+    let local_graph = build_local_graph(uri.to_string(), source, language_id, IndexerBackend::RubyIndexer);
     graph.consume_document_changes(local_graph);
 }
 
@@ -103,7 +120,7 @@ pub fn index_source(graph: &mut Graph, uri: &str, source: &str, language_id: &La
 /// # Panics
 ///
 /// Will panic if the graph cannot be wrapped in an Arc<Mutex<>>
-pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>) -> Vec<Errors> {
+pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>, backend: IndexerBackend) -> Vec<Errors> {
     let queue = Arc::new(JobQueue::new());
     let (local_graphs_tx, local_graphs_rx) = unbounded();
     let (errors_tx, errors_rx) = unbounded();
@@ -111,6 +128,7 @@ pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>) -> Vec<Errors> {
     for path in paths {
         queue.push(Box::new(IndexingJob::new(
             path,
+            backend,
             local_graphs_tx.clone(),
             errors_tx.clone(),
         )));
@@ -134,13 +152,21 @@ pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>) -> Vec<Errors> {
 }
 
 /// Indexes a source string using the appropriate indexer for the given language.
-fn build_local_graph(uri: String, source: &str, language: &LanguageId) -> LocalGraph {
+#[must_use]
+pub fn build_local_graph(uri: String, source: &str, language: &LanguageId, backend: IndexerBackend) -> LocalGraph {
     match language {
-        LanguageId::Ruby => {
-            let mut indexer = RubyIndexer::new(uri, source);
-            indexer.index();
-            indexer.local_graph()
-        }
+        LanguageId::Ruby => match backend {
+            IndexerBackend::RubyIndexer => {
+                let mut indexer = RubyIndexer::new(uri, source);
+                indexer.index();
+                indexer.local_graph()
+            }
+            IndexerBackend::OperationBuilder => {
+                let builder = RubyOperationBuilder::new(uri, source);
+                let result = builder.build();
+                crate::operation::applier::apply_operations(result)
+            }
+        },
         LanguageId::Rbs => {
             let mut indexer = RBSIndexer::new(uri, source);
             indexer.index();
@@ -175,7 +201,7 @@ mod tests {
         let relative_to_pwd = &dots.join(absolute_path);
 
         let mut graph = Graph::new();
-        let errors = index_files(&mut graph, vec![relative_to_pwd.clone()]);
+        let errors = index_files(&mut graph, vec![relative_to_pwd.clone()], IndexerBackend::RubyIndexer);
 
         assert!(errors.is_empty());
         assert_eq!(graph.documents().len(), 2);
@@ -196,7 +222,7 @@ mod tests {
         let uri = Url::from_file_path(&path).unwrap().to_string();
 
         let mut graph = Graph::new();
-        let errors = index_files(&mut graph, vec![path]);
+        let errors = index_files(&mut graph, vec![path], IndexerBackend::RubyIndexer);
 
         assert!(errors.is_empty(), "Expected no errors, got: {errors:#?}");
         assert_eq!(6, graph.definitions().len());

data/rust/rubydex/src/lib.rs

@@ -7,6 +7,7 @@ pub mod job_queue;
 pub mod listing;
 pub mod model;
 pub mod offset;
+pub mod operation;
 pub mod position;
 pub mod query;
 pub mod resolution;

data/rust/rubydex/src/listing.rs

@@ -38,9 +38,14 @@ impl FileDiscoveryJob {
     }
 }
 
+fn is_indexable_file(path: &Path) -> bool {
+    path.extension()
+        .is_some_and(|ext| ext == "rb" || ext == "rake" || ext == "rbs" || ext == "ru")
+}
+
 impl FileDiscoveryJob {
     fn handle_file(&self, path: &Path) {
-        if path.extension().is_some_and(|ext| ext == "rb" || ext == "rbs") {
+        if is_indexable_file(path) {
             self.paths_tx
                 .send(path.to_path_buf())
                 .expect("file receiver dropped before run completion");
@@ -266,22 +271,28 @@ mod tests {
     }
 
     #[test]
-    fn collect_rbs_files() {
+    fn collect_indexable_files() {
         let context = Context::new();
         let ruby_file = PathBuf::from("lib").join("foo.rb");
+        let rake_file = PathBuf::from("lib").join("task.rake");
         let rbs_file = PathBuf::from("sig").join("foo.rbs");
+        let rack_file = PathBuf::from("config.ru");
         let txt_file = PathBuf::from("lib").join("notes.txt");
         context.touch(&ruby_file);
+        context.touch(&rake_file);
         context.touch(&rbs_file);
+        context.touch(&rack_file);
         context.touch(&txt_file);
 
-        let (files, errors) = collect_document_paths(&context, &["lib", "sig"]);
+        let (files, errors) = collect_document_paths(&context, &["lib", "sig", "config.ru"]);
 
         assert!(errors.is_empty());
 
         assert_eq!(
             [
+                rack_file.to_str().unwrap().to_string(),
                 ruby_file.to_str().unwrap().to_string(),
+                rake_file.to_str().unwrap().to_string(),
                 rbs_file.to_str().unwrap().to_string(),
             ],
             files.as_slice()

data/rust/rubydex/src/main.rs

@@ -2,7 +2,8 @@ use clap::{Parser, ValueEnum};
 use std::{collections::HashSet, mem};
 
 use rubydex::{
-    indexing, integrity, listing,
+    indexing::{self, IndexerBackend},
+    integrity, listing,
     model::graph::Graph,
     resolution::Resolver,
     stats::{
@@ -31,6 +32,14 @@ struct Args {
     #[arg(long = "check-integrity", help = "Check the integrity of the graph after resolution")]
     check_integrity: bool,
 
+    #[arg(
+        long = "indexer",
+        value_enum,
+        default_value = "ruby-indexer",
+        help = "Which indexer backend to use for Ruby files"
+    )]
+    indexer: Indexer,
+
     #[arg(
         long = "report-orphans",
         value_name = "PATH",
@@ -49,6 +58,21 @@ enum StopAfter {
     Resolution,
 }
 
+#[derive(Debug, Clone, ValueEnum)]
+enum Indexer {
+    RubyIndexer,
+    OperationBuilder,
+}
+
+impl From<&Indexer> for IndexerBackend {
+    fn from(indexer: &Indexer) -> Self {
+        match indexer {
+            Indexer::RubyIndexer => IndexerBackend::RubyIndexer,
+            Indexer::OperationBuilder => IndexerBackend::OperationBuilder,
+        }
+    }
+}
+
 fn exit(print_stats: bool) {
     if print_stats {
         Timer::print_breakdown();
@@ -80,7 +104,8 @@ fn main() {
     // Indexing
 
     let mut graph = Graph::new();
-    let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths) });
+    let backend = IndexerBackend::from(&args.indexer);
+    let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths, backend) });
 
     for error in errors {
         eprintln!("{error}");

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

@@ -29,7 +29,7 @@ use crate::{
     assert_mem_size,
     model::{
         comment::Comment,
-        ids::{ConstantReferenceId, DefinitionId, NameId, StringId, UriId},
+        ids::{self, ConstantReferenceId, DefinitionId, NameId, StringId, UriId},
         visibility::Visibility,
     },
     offset::Offset,
@@ -289,7 +289,7 @@ impl ClassDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        ids::namespace_definition_id(self.uri_id, &self.offset, self.name_id)
     }
 
     #[must_use]
@@ -411,7 +411,7 @@ impl SingletonClassDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        ids::namespace_definition_id(self.uri_id, &self.offset, self.name_id)
     }
 
     #[must_use]
@@ -515,7 +515,7 @@ impl ModuleDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        ids::namespace_definition_id(self.uri_id, &self.offset, self.name_id)
     }
 
     #[must_use]
@@ -611,7 +611,7 @@ impl ConstantDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        ids::namespace_definition_id(self.uri_id, &self.offset, self.name_id)
     }
 
     #[must_use]
@@ -926,7 +926,7 @@ pub struct MethodDefinition {
 assert_mem_size!(MethodDefinition, 96);
 
 /// The receiver of a singleton method definition.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Receiver {
     /// `def self.foo` - receiver is the enclosing definition (class, module, singleton class or DSL)
     SelfReceiver(DefinitionId),
@@ -965,18 +965,7 @@ impl MethodDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        let mut formatted_id = format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id);
-
-        if let Some(receiver) = &self.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());
-                }
-            }
-        }
-
-        DefinitionId::from(&formatted_id)
+        ids::method_definition_id(self.uri_id, &self.offset, self.str_id, self.receiver.as_ref())
     }
 
     #[must_use]

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

@@ -1,4 +1,8 @@
-use crate::{assert_mem_size, model::id::Id};
+use crate::{
+    assert_mem_size,
+    model::{definitions::Receiver, id::Id},
+    offset::Offset,
+};
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
 pub struct DeclarationMarker;
@@ -12,6 +16,28 @@ pub struct DefinitionMarker;
 pub type DefinitionId = Id<DefinitionMarker>;
 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))
+}
+
+#[must_use]
+pub fn method_definition_id(
+    uri_id: UriId,
+    offset: &Offset,
+    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()),
+        }
+    }
+    DefinitionId::from(&formatted_id)
+}
+
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
 pub struct UriMarker;
 // UriId represents the ID of a URI, which is the unique identifier for a document