rubydex 0.2.5-aarch64-linux → 0.2.7-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,

data/rust/rubydex/src/lib.rs

@@ -1,5 +1,13 @@
+// Setting the global allocator needs to happen during linking and consumers may not always want to change the global
+// allocator. We gate the usage of jemalloc with a cargo feature, so that consumers can decide if they want to use it
+#[cfg(all(feature = "jemalloc", not(target_os = "windows")))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
 pub mod compile_assertions;
+pub mod config;
 pub mod diagnostic;
+pub mod dot;
 pub mod errors;
 pub mod indexing;
 pub mod integrity;
@@ -12,7 +20,6 @@ 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/main.rs

@@ -2,6 +2,7 @@ use clap::{Parser, ValueEnum};
 use std::{collections::HashSet, mem};
 
 use rubydex::{
+    dot,
     indexing::{self, IndexerBackend},
     integrity, listing,
     model::graph::Graph,
@@ -10,7 +11,6 @@ use rubydex::{
         memory::MemoryStats,
         timer::{Timer, time_it},
     },
-    visualization::dot,
 };
 
 #[derive(Parser, Debug)]
@@ -23,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,
@@ -171,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

@@ -1,5 +1,4 @@
 use crate::assert_mem_size;
-use crate::diagnostic::Diagnostic;
 use crate::model::ids::{
     ClassVariableReferenceId, GlobalVariableReferenceId, InstanceVariableReferenceId, MethodReferenceId,
 };
@@ -16,6 +15,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)]
@@ -110,8 +110,6 @@ macro_rules! namespace_declaration {
             descendants: IdentityHashSet<DeclarationId>,
             /// The singleton class associated with this declaration
             singleton_class_id: Option<DeclarationId>,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
         }
 
         impl $name {
@@ -126,13 +124,11 @@ macro_rules! namespace_declaration {
                     ancestors: Ancestors::Partial(Vec::new()),
                     descendants: IdentityHashSet::default(),
                     singleton_class_id: None,
-                    diagnostics: Vec::new(),
                 }
             }
 
-            pub fn extend(&mut self, mut other: Declaration) {
+            pub fn extend(&mut self, other: Declaration) {
                 self.definition_ids.extend(other.definitions());
-                self.diagnostics.extend(other.take_diagnostics());
 
                 match other {
                     Declaration::Namespace(namespace) => {
@@ -242,8 +238,6 @@ macro_rules! simple_declaration {
             references: IdentityHashSet<$reference_type>,
             /// The ID of the owner of this declaration
             owner_id: DeclarationId,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
         }
 
         impl $name {
@@ -254,13 +248,11 @@ macro_rules! simple_declaration {
                     definition_ids: Vec::new(),
                     references: IdentityHashSet::default(),
                     owner_id,
-                    diagnostics: Vec::new(),
                 }
             }
 
-            pub fn extend(&mut self, mut other: $name) {
+            pub fn extend(&mut self, other: $name) {
                 self.definition_ids.extend(other.definitions());
-                self.diagnostics.extend(other.take_diagnostics());
                 self.references.extend(other.references());
             }
 
@@ -277,10 +269,6 @@ macro_rules! simple_declaration {
                 self.references.remove(reference_id);
             }
 
-            pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-                std::mem::take(&mut self.diagnostics)
-            }
-
             #[must_use]
             pub fn definitions(&self) -> &[DefinitionId] {
                 &self.definition_ids
@@ -435,23 +423,6 @@ impl Declaration {
         })
     }
 
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_declarations!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_declarations!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
-    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
-        all_declarations!(self, it => it.diagnostics.push(diagnostic));
-    }
-
-    pub fn clear_diagnostics(&mut self) {
-        all_declarations!(self, it => it.diagnostics.clear());
-    }
-
     #[must_use]
     pub fn reference_count(&self) -> usize {
         all_declarations!(self, it => it.references.len())
@@ -545,15 +516,6 @@ impl Namespace {
         all_namespaces!(self, it => &it.members)
     }
 
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_namespaces!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_namespaces!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
     pub fn extend(&mut self, other: Declaration) {
         all_namespaces!(self, it => it.extend(other));
     }
@@ -646,25 +608,25 @@ impl Namespace {
 }
 
 namespace_declaration!(Class, ClassDeclaration);
-assert_mem_size!(ClassDeclaration, 216);
+assert_mem_size!(ClassDeclaration, 192);
 namespace_declaration!(Module, ModuleDeclaration);
-assert_mem_size!(ModuleDeclaration, 216);
+assert_mem_size!(ModuleDeclaration, 192);
 namespace_declaration!(SingletonClass, SingletonClassDeclaration);
-assert_mem_size!(SingletonClassDeclaration, 216);
+assert_mem_size!(SingletonClassDeclaration, 192);
 namespace_declaration!(Todo, TodoDeclaration);
-assert_mem_size!(TodoDeclaration, 216);
+assert_mem_size!(TodoDeclaration, 192);
 simple_declaration!(ConstantDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantDeclaration, 112);
+assert_mem_size!(ConstantDeclaration, 88);
 simple_declaration!(MethodDeclaration, MethodReferenceId);
-assert_mem_size!(MethodDeclaration, 112);
+assert_mem_size!(MethodDeclaration, 88);
 simple_declaration!(GlobalVariableDeclaration, GlobalVariableReferenceId);
-assert_mem_size!(GlobalVariableDeclaration, 112);
+assert_mem_size!(GlobalVariableDeclaration, 88);
 simple_declaration!(InstanceVariableDeclaration, InstanceVariableReferenceId);
-assert_mem_size!(InstanceVariableDeclaration, 112);
+assert_mem_size!(InstanceVariableDeclaration, 88);
 simple_declaration!(ClassVariableDeclaration, ClassVariableReferenceId);
-assert_mem_size!(ClassVariableDeclaration, 112);
+assert_mem_size!(ClassVariableDeclaration, 88);
 simple_declaration!(ConstantAliasDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantAliasDeclaration, 112);
+assert_mem_size!(ConstantAliasDeclaration, 88);
 
 #[cfg(test)]
 mod tests {

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

@@ -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]
@@ -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,7 +928,7 @@ 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, Clone)]
@@ -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,
@@ -983,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