rubydex 0.2.4-aarch64-linux → 0.2.6-aarch64-linux

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

@@ -338,6 +338,7 @@ impl<'a> RBSIndexer<'a> {
         &mut self,
         str_id: StringId,
         offset: Offset,
+        name_offset: Offset,
         comments: Box<[Comment]>,
         flags: DefinitionFlags,
         lexical_nesting_id: Option<DefinitionId>,
@@ -347,6 +348,7 @@ impl<'a> RBSIndexer<'a> {
             str_id,
             self.uri_id,
             offset.clone(),
+            name_offset.clone(),
             comments.clone(),
             flags.clone(),
             lexical_nesting_id,
@@ -360,6 +362,7 @@ impl<'a> RBSIndexer<'a> {
             str_id,
             self.uri_id,
             offset,
+            name_offset,
             comments,
             flags,
             lexical_nesting_id,
@@ -562,13 +565,22 @@ impl Visit for RBSIndexer<'_> {
     fn visit_method_definition_node(&mut self, def_node: &node::MethodDefinitionNode) {
         let str_id = self.local_graph.intern_string(format!("{}()", def_node.name()));
         let offset = Offset::from_rbs_location(&def_node.location());
+        let name_offset = Offset::from_rbs_location(&def_node.name_location());
         let comments = self.collect_comments(def_node.comment());
         let flags = Self::flags(&def_node.annotations());
         let lexical_nesting_id = self.parent_lexical_scope_id();
         let signatures = self.collect_overload_signatures(def_node);
 
         if def_node.kind() == node::MethodDefinitionKind::SingletonInstance {
-            self.register_singleton_instance_method(str_id, offset, comments, flags, lexical_nesting_id, signatures);
+            self.register_singleton_instance_method(
+                str_id,
+                offset,
+                name_offset,
+                comments,
+                flags,
+                lexical_nesting_id,
+                signatures,
+            );
             return;
         }
 
@@ -602,6 +614,7 @@ impl Visit for RBSIndexer<'_> {
             str_id,
             self.uri_id,
             offset,
+            name_offset,
             comments,
             flags,
             lexical_nesting_id,
@@ -1197,6 +1210,7 @@ mod tests {
 
             assert_definition_at!(&context, "2:3-2:22", Method, |def| {
                 assert_def_str_eq!(&context, def, "foo()");
+                assert_def_name_offset_eq!(&context, def, "2:7-2:10");
                 assert!(def.receiver().is_none());
                 assert_eq!(def.visibility(), &Visibility::Public);
                 assert_eq!(class_def.id(), def.lexical_nesting_id().unwrap());
@@ -1205,6 +1219,7 @@ mod tests {
 
             assert_definition_at!(&context, "4:3-4:23", Method, |def| {
                 assert_def_str_eq!(&context, def, "bar()");
+                assert_def_name_offset_eq!(&context, def, "4:7-4:10");
                 assert!(def.receiver().is_none());
                 assert_eq!(def.visibility(), &Visibility::Public);
                 assert_eq!(class_def.id(), def.lexical_nesting_id().unwrap());
@@ -1398,6 +1413,7 @@ mod tests {
             panic!()
         };
         assert_def_str_eq!(&context, instance_method, "foo()");
+        assert_def_name_offset_eq!(&context, instance_method, "2:13-2:16");
         assert_eq!(instance_method.visibility(), &Visibility::Private);
 
         let singleton_method = definitions
@@ -1408,6 +1424,7 @@ mod tests {
             panic!()
         };
         assert_def_str_eq!(&context, singleton_method, "foo()");
+        assert_def_name_offset_eq!(&context, singleton_method, "2:13-2:16");
         assert_eq!(singleton_method.visibility(), &Visibility::Public);
     }
 
@@ -1425,6 +1442,7 @@ mod tests {
 
         assert_definition_at!(&context, "2:3-2:27", Method, |def| {
             assert_def_str_eq!(&context, def, "foo()");
+            assert_def_name_offset_eq!(&context, def, "2:12-2:15");
             let sigs = def.signatures().as_slice();
             assert_eq!(sigs.len(), 1);
             assert_eq!(sigs[0].len(), 0);

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

@@ -1811,6 +1811,7 @@ impl Visit<'_> for RubyIndexer<'_> {
         let name = Self::location_to_string(&node.name_loc());
         let str_id = self.local_graph.intern_string(format!("{name}()"));
         let offset = Offset::from_prism_location(&node.location());
+        let name_offset = Offset::from_prism_location(&node.name_loc());
         let parent_nesting_id = self.current_nesting_definition_id();
         let parameters = self.collect_parameters(node);
         let is_singleton = node.receiver().is_some();
@@ -1862,6 +1863,7 @@ impl Visit<'_> for RubyIndexer<'_> {
                 str_id,
                 self.uri_id,
                 offset.clone(),
+                name_offset.clone(),
                 comments.clone(),
                 flags.clone(),
                 parent_nesting_id,
@@ -1878,6 +1880,7 @@ impl Visit<'_> for RubyIndexer<'_> {
                 str_id,
                 self.uri_id,
                 offset,
+                name_offset,
                 comments,
                 flags,
                 parent_nesting_id,
@@ -1895,6 +1898,7 @@ impl Visit<'_> for RubyIndexer<'_> {
                 str_id,
                 self.uri_id,
                 offset,
+                name_offset,
                 comments,
                 flags,
                 parent_nesting_id,
@@ -2481,5 +2485,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

@@ -1,5 +1,6 @@
 pub mod compile_assertions;
 pub mod diagnostic;
+pub mod dot;
 pub mod errors;
 pub mod indexing;
 pub mod integrity;
@@ -7,11 +8,11 @@ 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;
 pub mod stats;
-pub mod visualization;
 
 #[cfg(any(test, feature = "test_utils"))]
 pub mod test_utils;

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,14 +2,15 @@ use clap::{Parser, ValueEnum};
 use std::{collections::HashSet, mem};
 
 use rubydex::{
-    indexing, integrity, listing,
+    dot,
+    indexing::{self, IndexerBackend},
+    integrity, listing,
     model::graph::Graph,
     resolution::Resolver,
     stats::{
         memory::MemoryStats,
         timer::{Timer, time_it},
     },
-    visualization::dot,
 };
 
 #[derive(Parser, Debug)]
@@ -22,8 +23,11 @@ struct Args {
     #[arg(long = "stop-after", help = "Stop after the given stage")]
     stop_after: Option<StopAfter>,
 
-    #[arg(long = "visualize")]
-    visualize: bool,
+    #[arg(long = "dot", help = "Output a DOT graph visualization")]
+    dot: bool,
+
+    #[arg(long = "show-builtins", help = "Include built-in declarations in DOT output")]
+    show_builtins: bool,
 
     #[arg(long = "stats", help = "Show detailed performance statistics")]
     stats: bool,
@@ -31,6 +35,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 +61,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 +107,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}");
@@ -146,8 +174,8 @@ fn main() {
     }
 
     // Generate visualization or print statistics
-    if args.visualize {
-        println!("{}", dot::generate(&graph));
+    if args.dot {
+        println!("{}", dot::DotBuilder::generate(&graph, args.show_builtins));
     } else {
         println!("Indexed {} files", graph.documents().len());
         println!("Found {} names", graph.declarations().len());

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

@@ -7,10 +7,13 @@ use crate::{
     model::{
         declaration::{ClassDeclaration, Declaration, Namespace},
         graph::Graph,
-        ids::DeclarationId,
+        ids::{DeclarationId, UriId},
     },
 };
 
+pub const BUILT_IN_URI: &str = "rubydex:built-in";
+pub static BUILT_IN_URI_ID: LazyLock<UriId> = LazyLock::new(|| UriId::from(BUILT_IN_URI));
+
 pub static KERNEL_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Kernel"));
 pub static BASIC_OBJECT_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("BasicObject"));
 pub static OBJECT_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Object"));
@@ -27,7 +30,7 @@ pub fn add_built_in_data(graph: &mut Graph) {
     // We need definitions to ensure that ancestor linearization happens naturally through the algorithm. Trying to set
     // ancestors directly on declarations doesn't work because the algorithm erases the ancestors and there are no
     // definitions to inform it of the superclasses and mixins.
-    let uri = Url::parse("rubydex:built-in").unwrap();
+    let uri = Url::parse(BUILT_IN_URI).unwrap();
     let source = r"
       class BasicObject
       end

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

@@ -1,3 +1,4 @@
+use crate::assert_mem_size;
 use crate::offset::Offset;
 
 #[derive(Debug, Clone)]
@@ -5,6 +6,7 @@ pub struct Comment {
     offset: Offset,
     string: String,
 }
+assert_mem_size!(Comment, 32);
 
 impl Comment {
     #[must_use]

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

@@ -16,6 +16,7 @@ pub enum Ancestor {
     /// A partial ancestor that is missing linearization
     Partial(NameId),
 }
+assert_mem_size!(Ancestor, 16);
 
 /// The ancestor chain and its current state
 #[derive(Debug, Clone)]

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,
@@ -43,6 +43,7 @@ bitflags! {
         const SINGLETON_METHOD_VISIBILITY = 0b0100;
     }
 }
+assert_mem_size!(DefinitionFlags, 1);
 
 impl DefinitionFlags {
     #[must_use]
@@ -181,6 +182,7 @@ impl Definition {
             Definition::Class(d) => Some(d.name_offset()),
             Definition::Module(d) => Some(d.name_offset()),
             Definition::SingletonClass(d) => Some(d.name_offset()),
+            Definition::Method(d) => Some(d.name_offset()),
             _ => None,
         }
     }
@@ -199,6 +201,7 @@ pub enum Mixin {
     Prepend(PrependDefinition),
     Extend(ExtendDefinition),
 }
+assert_mem_size!(Mixin, 16);
 
 impl Mixin {
     #[must_use]
@@ -289,7 +292,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 +414,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 +518,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 +614,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]
@@ -891,6 +894,7 @@ pub enum Signatures {
     /// Used for RBS definitions with more than one overload.
     Overloaded(Box<[Signature]>),
 }
+assert_mem_size!(Signatures, 24);
 
 impl Signatures {
     /// Returns all signatures as a slice, regardless of variant.
@@ -915,6 +919,7 @@ pub struct MethodDefinition {
     str_id: StringId,
     uri_id: UriId,
     offset: Offset,
+    name_offset: Offset,
     flags: DefinitionFlags,
     comments: Box<[Comment]>,
     lexical_nesting_id: Option<DefinitionId>,
@@ -923,10 +928,10 @@ pub struct MethodDefinition {
     receiver: Option<Receiver>,
 }
 
-assert_mem_size!(MethodDefinition, 96);
+assert_mem_size!(MethodDefinition, 104);
 
 /// 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),
@@ -943,6 +948,7 @@ impl MethodDefinition {
         str_id: StringId,
         uri_id: UriId,
         offset: Offset,
+        name_offset: Offset,
         comments: Box<[Comment]>,
         flags: DefinitionFlags,
         lexical_nesting_id: Option<DefinitionId>,
@@ -954,6 +960,7 @@ impl MethodDefinition {
             str_id,
             uri_id,
             offset,
+            name_offset,
             flags,
             comments,
             lexical_nesting_id,
@@ -965,18 +972,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]
@@ -994,6 +990,11 @@ impl MethodDefinition {
         &self.offset
     }
 
+    #[must_use]
+    pub fn name_offset(&self) -> &Offset {
+        &self.name_offset
+    }
+
     #[must_use]
     pub fn comments(&self) -> &[Comment] {
         &self.comments

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

@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use line_index::LineIndex;
 use url::Url;
 
+use crate::assert_mem_size;
 use crate::diagnostic::Diagnostic;
 use crate::model::ids::{ConstantReferenceId, DefinitionId, MethodReferenceId};
 
@@ -17,6 +18,7 @@ pub struct Document {
     constant_reference_ids: Vec<ConstantReferenceId>,
     diagnostics: Vec<Diagnostic>,
 }
+assert_mem_size!(Document, 176);
 
 impl Document {
     #[must_use]

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

@@ -1,3 +1,4 @@
+use crate::assert_mem_size;
 use line_index::WideEncoding;
 
 #[derive(Default, Debug)]
@@ -7,6 +8,7 @@ pub enum Encoding {
     Utf16,
     Utf32,
 }
+assert_mem_size!(Encoding, 1);
 
 impl Encoding {
     /// Transform the LSP selected encoding into the expected `WideEncoding` for converting code units with the