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

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

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.