rubydex 0.2.5 → 0.2.6

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,6 @@
 pub mod compile_assertions;
 pub mod diagnostic;
+pub mod dot;
 pub mod errors;
 pub mod indexing;
 pub mod integrity;
@@ -12,7 +13,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

@@ -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

@@ -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

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

@@ -2,6 +2,7 @@ use std::collections::HashSet;
 use std::collections::hash_map::Entry;
 use std::path::PathBuf;
 
+use crate::assert_mem_size;
 use crate::diagnostic::Diagnostic;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
@@ -28,6 +29,7 @@ pub enum NameDependent {
     /// This name's `nesting` is the key name — reference-only dependency.
     NestedName(NameId),
 }
+assert_mem_size!(NameDependent, 16);
 
 /// Items processed by the unified invalidation worklist.
 enum InvalidationItem {
@@ -38,6 +40,7 @@ enum InvalidationItem {
     /// Ancestor context changed — unresolve references under this name but keep the name resolved.
     References(NameId),
 }
+assert_mem_size!(InvalidationItem, 16);
 
 /// A work item produced by graph mutations (update/delete) that needs resolution.
 #[derive(Debug)]
@@ -49,6 +52,7 @@ pub enum Unit {
     /// A declaration whose ancestors need re-linearization
     Ancestors(DeclarationId),
 }
+assert_mem_size!(Unit, 16);
 
 // The `Graph` is the global representation of the entire Ruby codebase. It contains all declarations and their
 // relationships
@@ -84,6 +88,7 @@ pub struct Graph {
     /// Paths to exclude from file discovery during indexing.
     excluded_paths: HashSet<PathBuf>,
 }
+assert_mem_size!(Graph, 336);
 
 impl Graph {
     #[must_use]
@@ -306,9 +311,6 @@ impl Graph {
         self.definition_to_declaration_id(self.definitions.get(&definition_id).unwrap())
     }
 
-    /// # Panics
-    ///
-    /// Panics if the definition is not found
     #[must_use]
     pub fn definition_to_declaration_id(&self, definition: &Definition) -> Option<&DeclarationId> {
         let (nesting_name_id, member_str_id) = match definition {
@@ -442,20 +444,21 @@ impl Graph {
     }
 
     /// Looks up the declaration for a `SelfReceiver` method/alias through the singleton class.
+    ///
+    /// Returns `None` when the owner cannot be resolved to a namespace with a singleton class. This
+    /// can happen when the enclosing construct resolved to a non-namespace declaration (e.g. a
+    /// constant or constant alias that a same-named `class`/`module` reopened without promotion), in
+    /// which case the method has no owning declaration.
     fn find_self_receiver_declaration(&self, def_id: DefinitionId, member_str_id: StringId) -> Option<&DeclarationId> {
         let owner_decl_id = self.definition_id_to_declaration_id(def_id)?;
         let singleton_id = self
             .declarations
-            .get(owner_decl_id)
-            .unwrap()
-            .as_namespace()
-            .unwrap()
+            .get(owner_decl_id)?
+            .as_namespace()?
             .singleton_class()?;
         self.declarations
-            .get(singleton_id)
-            .unwrap()
-            .as_namespace()
-            .unwrap()
+            .get(singleton_id)?
+            .as_namespace()?
             .member(&member_str_id)
     }
 
@@ -1540,8 +1543,8 @@ mod tests {
     use crate::model::declaration::Ancestors;
     use crate::test_utils::GraphTest;
     use crate::{
-        assert_declaration_does_not_exist, assert_dependents, assert_descendants, assert_members_eq,
-        assert_no_diagnostics, assert_no_members,
+        assert_declaration_does_not_exist, assert_declaration_kind_eq, assert_dependents, assert_descendants,
+        assert_members_eq, assert_no_diagnostics, assert_no_members,
     };
 
     #[test]
@@ -1563,6 +1566,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn singleton_method_in_non_namespace_owner_does_not_panic() {
+        // `Aliased = Bar` assigns a constant to another constant, producing a (non-promotable)
+        // `ConstantAlias` declaration. Reopening it with `class Aliased` is valid Ruby (it reopens
+        // `Bar`), but the class definition is attached to the existing `ConstantAlias` declaration
+        // without promoting it to a namespace. A `def self.foo` inside then has a `SelfReceiver`
+        // owner whose declaration is not a namespace. Resolving that definition to its declaration
+        // must return `None` rather than panicking.
+        let mut context = GraphTest::new();
+
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Bar
+            end
+
+            Aliased = Bar
+
+            class Aliased
+              def self.foo; end
+            end
+            ",
+        );
+        context.resolve();
+
+        // The declaration stays a non-namespace constant alias.
+        assert_declaration_kind_eq!(context, "Aliased", "ConstantAlias");
+
+        // Mirrors what consumers like the DOT exporter do: resolve every definition to its
+        // declaration. This previously panicked on the singleton method's non-namespace owner.
+        for definition in context.graph().definitions().values() {
+            let _ = context.graph().definition_to_declaration_id(definition);
+        }
+    }
+
     #[test]
     fn deleting_file_triggers_name_dependent_cleanup() {
         let mut context = GraphTest::new();

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

@@ -6,10 +6,13 @@ use std::{
     hash::{BuildHasher, Hasher},
 };
 
+use crate::assert_mem_size;
+
 #[derive(Default)]
 pub struct IdentityHasher {
     hash: u64,
 }
+assert_mem_size!(IdentityHasher, 8);
 
 impl Hasher for IdentityHasher {
     fn write(&mut self, _bytes: &[u8]) {

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

@@ -1,3 +1,5 @@
+use crate::assert_mem_size;
+
 /// A Ruby keyword with its documentation.
 #[derive(Debug)]
 pub struct Keyword {
@@ -6,6 +8,7 @@ pub struct Keyword {
     /// Documentation string for hover display
     documentation: &'static str,
 }
+assert_mem_size!(Keyword, 32);
 
 impl Keyword {
     #[must_use]

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

@@ -141,6 +141,7 @@ pub struct ResolvedName {
     name: Name,
     declaration_id: DeclarationId,
 }
+assert_mem_size!(ResolvedName, 48);
 
 impl ResolvedName {
     #[must_use]
@@ -173,6 +174,7 @@ pub enum NameRef {
     /// This name has been resolved to an existing declaration
     Resolved(Box<ResolvedName>),
 }
+assert_mem_size!(NameRef, 16);
 
 impl NameRef {
     #[must_use]

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

@@ -1,3 +1,4 @@
+use crate::assert_mem_size;
 use std::ops::Deref;
 
 /// A reference-counted string used in the graph.
@@ -11,6 +12,7 @@ pub struct StringRef {
     value: String,
     ref_count: u32,
 }
+assert_mem_size!(StringRef, 32);
 
 impl StringRef {
     #[must_use]

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

@@ -1,6 +1,8 @@
 use core::fmt;
 use std::fmt::Display;
 
+use crate::assert_mem_size;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Visibility {
     Public,
@@ -8,6 +10,7 @@ pub enum Visibility {
     Private,
     ModuleFunction,
 }
+assert_mem_size!(Visibility, 1);
 
 impl Visibility {
     /// Parse a visibility from a string.

data/rust/rubydex/src/operation/applier.rs

@@ -219,6 +219,7 @@ impl OperationApplier {
             op.str_id,
             op.uri_id,
             op.offset,
+            op.name_offset,
             op.comments,
             op.flags,
             lexical_nesting_id,

data/rust/rubydex/src/operation/mod.rs

@@ -152,6 +152,7 @@ pub struct EnterMethod {
     pub str_id: StringId,
     pub uri_id: UriId,
     pub offset: Offset,
+    pub name_offset: Offset,
     pub comments: Box<[Comment]>,
     pub flags: DefinitionFlags,
     pub signatures: Signatures,

data/rust/rubydex/src/operation/ruby_builder.rs

@@ -1524,6 +1524,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
         let name = Self::location_to_string(&node.name_loc());
         let str_id = self.intern_string(format!("{name}()"));
         let offset = Offset::from_prism_location(&node.location());
+        let name_offset = Offset::from_prism_location(&node.name_loc());
         let parameters = self.collect_parameters(node);
         let is_singleton = node.receiver().is_some();
 
@@ -1586,6 +1587,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 str_id,
                 uri_id: self.uri_id,
                 offset: offset.clone(),
+                name_offset: name_offset.clone(),
                 comments: comments.clone(),
                 flags: flags.clone(),
                 signatures: Signatures::Simple(parameters.clone().into_boxed_slice()),
@@ -1604,6 +1606,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 str_id,
                 uri_id: self.uri_id,
                 offset: offset.clone(),
+                name_offset: name_offset.clone(),
                 comments,
                 flags,
                 signatures: Signatures::Simple(parameters.into_boxed_slice()),
@@ -1638,6 +1641,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 str_id,
                 uri_id: self.uri_id,
                 offset: offset.clone(),
+                name_offset,
                 comments,
                 flags,
                 signatures: Signatures::Simple(parameters.into_boxed_slice()),