rubydex 0.2.5 → 0.2.7

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

@@ -1,8 +1,11 @@
 use std::collections::HashSet;
 use std::collections::hash_map::Entry;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
+use crate::assert_mem_size;
+use crate::config::Config;
 use crate::diagnostic::Diagnostic;
+use crate::errors::Errors;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
 use crate::model::declaration::{Ancestor, Declaration, Namespace};
@@ -28,6 +31,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 +42,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 +54,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
@@ -81,9 +87,10 @@ pub struct Graph {
     /// Drained by `take_pending_work()` before resolution.
     pending_work: Vec<Unit>,
 
-    /// Paths to exclude from file discovery during indexing.
-    excluded_paths: HashSet<PathBuf>,
+    /// Project configuration
+    config: Config,
 }
+assert_mem_size!(Graph, 352);
 
 impl Graph {
     #[must_use]
@@ -99,7 +106,7 @@ impl Graph {
             position_encoding: Encoding::default(),
             name_dependents: IdentityHashMap::default(),
             pending_work: Vec::default(),
-            excluded_paths: HashSet::new(),
+            config: Config::new(),
         };
 
         add_built_in_data(&mut graph);
@@ -121,13 +128,40 @@ impl Graph {
     /// Adds paths to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
     /// directory traversal.
     pub fn exclude_paths(&mut self, paths: Vec<PathBuf>) {
-        self.excluded_paths.extend(paths);
+        self.config.exclude_paths(paths);
     }
 
     /// Returns the set of paths excluded from file discovery.
     #[must_use]
-    pub fn excluded_paths(&self) -> &HashSet<PathBuf> {
-        &self.excluded_paths
+    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
+        self.config.excluded_paths()
+    }
+
+    /// Returns the root directory of the workspace being indexed.
+    #[must_use]
+    pub fn workspace_path(&self) -> &Path {
+        self.config.workspace_path()
+    }
+
+    /// Sets the root directory of the workspace being indexed.
+    pub fn set_workspace_path(&mut self, workspace_path: PathBuf) {
+        self.config.set_workspace_path(workspace_path);
+    }
+
+    /// Loads a configuration file. Pass `None` to load the default `rubydex.toml` configuration file if it exists
+    ///
+    /// # Errors
+    ///
+    /// Returns an [`Errors::ConfigNotFound`] if an explicitly requested file does not exist or an
+    /// [`Errors::ConfigError`] if a file cannot otherwise be read or its contents are malformed.
+    pub fn load_config(&mut self, config_path: Option<&Path>) -> Result<(), Errors> {
+        match config_path {
+            Some(path) => {
+                let path = self.config.workspace_path().join(path);
+                self.config.load_file(&path)
+            }
+            None => self.config.load_default(),
+        }
     }
 
     /// # Panics
@@ -306,9 +340,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 +473,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)
     }
 
@@ -483,10 +515,7 @@ impl Graph {
 
     #[must_use]
     pub fn all_diagnostics(&self) -> Vec<&Diagnostic> {
-        let document_diagnostics = self.documents.values().flat_map(Document::diagnostics);
-        let declaration_diagnostics = self.declarations.values().flat_map(Declaration::diagnostics);
-
-        document_diagnostics.chain(declaration_diagnostics).collect()
+        self.documents.values().flat_map(Document::diagnostics).collect()
     }
 
     /// Interns a string in the graph unless already interned. This method is only used to back the
@@ -1198,9 +1227,6 @@ impl Graph {
             for def_id in detach_def_ids {
                 decl.remove_definition(def_id);
             }
-            if !detach_def_ids.is_empty() {
-                decl.clear_diagnostics();
-            }
         }
 
         let Some(decl) = self.declarations.get(&decl_id) else {
@@ -1540,8 +1566,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 +1589,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()),

data/rust/rubydex/src/query.rs

@@ -454,20 +454,7 @@ fn expression_completion<'a>(
     let NameRef::Resolved(name_ref) = name_ref else {
         return Err(format!("Expected name {nesting_name_id} to be resolved").into());
     };
-    // When no explicit self is given, self is the innermost lexical scope (the nesting's own declaration).
-    // When explicit, follow constant aliases so callers can pass whatever the expression that set self
-    // resolves to without having to unwrap aliases themselves. Missing or non-namespace decls are graph
-    // inconsistencies and surfaced as errors.
-    let resolved_self_decl_id = match self_decl_id {
-        Some(id) => resolve_self_namespace(graph, id)?,
-        None => *name_ref.declaration_id(),
-    };
-    let self_decl = graph
-        .declarations()
-        .get(&resolved_self_decl_id)
-        .unwrap()
-        .as_namespace()
-        .ok_or("Expected associated declaration to be a namespace")?;
+
     let innermost_lexical_decl = graph
         .declarations()
         .get(name_ref.declaration_id())
@@ -496,7 +483,16 @@ fn expression_completion<'a>(
 
     // Collect methods and instance variables, which are based on the inheritance chain of the `self` type (which may
     // not match the immediate lexical scope)
-    collect_methods_and_ivars_from_self(graph, self_decl, &mut context, &mut candidates);
+    if let Some(self_decl_id) = self_decl_id.map(|id| resolve_self_namespace(graph, id)).transpose()? {
+        let self_decl = graph
+            .declarations()
+            .get(&self_decl_id)
+            .unwrap()
+            .as_namespace()
+            .ok_or("Expected associated declaration to be a namespace")?;
+
+        collect_methods_and_ivars_from_self(graph, self_decl, &mut context, &mut candidates);
+    }
 
     // Keywords are always available in expression contexts
     candidates.extend(keywords::KEYWORDS.iter().map(CompletionCandidate::Keyword));
@@ -1120,7 +1116,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Child")),
                 nesting_name_id: name_id,
             },
             [
@@ -1169,7 +1165,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Child")),
                 nesting_name_id: name_id,
             },
             [
@@ -1218,7 +1214,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
             },
             [
@@ -1268,7 +1264,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>")),
                 nesting_name_id: name_id,
             },
             [
@@ -1288,7 +1284,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1305,6 +1301,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn completion_candidates_for_instance_variables_inside_singleton_class_body() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Foo
+              @class_level_ivar = 1
+
+              def initialize
+                @instance_level_ivar = 1
+              end
+
+              class << self
+                @singleton_level_ivar = 1
+              end
+            end
+            ",
+        );
+        context.resolve();
+
+        let foo_id = Name::new(StringId::from("Foo"), ParentScope::None, None).id();
+        let name_id = Name::new(StringId::from("<Foo>"), ParentScope::Attached(foo_id), Some(foo_id)).id();
+
+        assert_declaration_completion_eq!(
+            context,
+            CompletionReceiver::Expression {
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>::<<Foo>>")),
+                nesting_name_id: name_id,
+            },
+            [
+                "Module",
+                "Class",
+                "Object",
+                "BasicObject",
+                "Kernel",
+                "Foo",
+                "Foo::<Foo>::<<Foo>>#@singleton_level_ivar"
+            ]
+        );
+    }
+
     #[test]
     fn completion_candidates_includes_constants_accessible_within_lexical_scope() {
         let mut context = GraphTest::new();
@@ -1337,10 +1375,11 @@ mod tests {
             Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
         )
         .id();
+
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1361,7 +1400,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1405,7 +1444,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1452,7 +1491,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::Bar")),
                 nesting_name_id: name_id,
             },
             ["Foo::Bar", "$var2", "$var", "Foo::Bar#bar_m()"]
@@ -1982,7 +2021,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#greet()"),
             },
@@ -2000,6 +2039,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn method_argument_in_body_completion_uses_singleton_self() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Foo
+              @class_level_ivar = 1
+
+              def instance_method; end
+
+              def self.configure(name:, label: 'default'); end
+
+              # `configure(...)` is invoked at class body level — cursor inside the args.
+            end
+            ",
+        );
+        context.resolve();
+
+        let name_id = Name::new(StringId::from("Foo"), ParentScope::None, None).id();
+        assert_declaration_completion_eq!(
+            context,
+            CompletionReceiver::MethodArgument {
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>")),
+                nesting_name_id: name_id,
+                method_decl_id: DeclarationId::from("Foo::<Foo>#configure()"),
+            },
+            [
+                "Module",
+                "Class",
+                "Object",
+                "BasicObject",
+                "Kernel",
+                "Foo",
+                "Foo::<Foo>#configure()",
+                "Foo::<Foo>#@class_level_ivar",
+                "name:",
+                "label:"
+            ]
+        );
+    }
+
     #[test]
     fn method_argument_completion_no_keyword_params() {
         let mut context = GraphTest::new();
@@ -2018,7 +2099,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2044,7 +2125,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#search()"),
             },
@@ -2088,7 +2169,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2181,7 +2262,7 @@ mod tests {
         assert_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2612,7 +2693,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Object")),
                 nesting_name_id: name_id,
             },
             [
@@ -2950,7 +3031,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: foo_name_id,
             },
             [
@@ -2970,7 +3051,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: bar_name_id,
             },
             [
@@ -3286,7 +3367,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: foo_name_id,
             },
             [