rubydex 0.2.0 → 0.2.2

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

@@ -339,6 +339,54 @@ impl Declaration {
         }
     }
 
+    #[must_use]
+    pub fn as_constant(&self) -> Option<&ConstantDeclaration> {
+        match self {
+            Declaration::Constant(constant) => Some(constant),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_constant_alias(&self) -> Option<&ConstantAliasDeclaration> {
+        match self {
+            Declaration::ConstantAlias(alias) => Some(alias),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_method(&self) -> Option<&MethodDeclaration> {
+        match self {
+            Declaration::Method(method) => Some(method),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_global_variable(&self) -> Option<&GlobalVariableDeclaration> {
+        match self {
+            Declaration::GlobalVariable(global) => Some(global),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_class_variable(&self) -> Option<&ClassVariableDeclaration> {
+        match self {
+            Declaration::ClassVariable(cvar) => Some(cvar),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_instance_variable(&self) -> Option<&InstanceVariableDeclaration> {
+        match self {
+            Declaration::InstanceVariable(ivar) => Some(ivar),
+            _ => None,
+        }
+    }
+
     #[must_use]
     pub fn definitions(&self) -> &[DefinitionId] {
         all_declarations!(self, it => &it.definition_ids)

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

@@ -40,6 +40,7 @@ bitflags! {
     pub struct DefinitionFlags: u8 {
         const DEPRECATED = 0b0001;
         const PROMOTABLE = 0b0010;
+        const SINGLETON_METHOD_VISIBILITY = 0b0100;
     }
 }
 
@@ -53,6 +54,11 @@ impl DefinitionFlags {
     pub fn is_promotable(&self) -> bool {
         self.contains(Self::PROMOTABLE)
     }
+
+    #[must_use]
+    pub fn is_singleton_method_visibility(&self) -> bool {
+        self.contains(Self::SINGLETON_METHOD_VISIBILITY)
+    }
 }
 
 #[derive(Debug)]
@@ -155,8 +161,8 @@ impl Definition {
             Definition::Module(d) => Some(d.name_id()),
             Definition::Constant(d) => Some(d.name_id()),
             Definition::ConstantAlias(d) => Some(d.name_id()),
-            Definition::ConstantVisibility(d) => Some(d.name_id()),
-            Definition::MethodVisibility(_)
+            Definition::ConstantVisibility(_)
+            | Definition::MethodVisibility(_)
             | Definition::GlobalVariable(_)
             | Definition::InstanceVariable(_)
             | Definition::ClassVariable(_)
@@ -711,7 +717,8 @@ impl ConstantAliasDefinition {
 
 #[derive(Debug)]
 pub struct ConstantVisibilityDefinition {
-    name_id: NameId,
+    receiver: Option<NameId>,
+    target: StringId,
     visibility: Visibility,
     uri_id: UriId,
     offset: Offset,
@@ -722,8 +729,10 @@ pub struct ConstantVisibilityDefinition {
 
 impl ConstantVisibilityDefinition {
     #[must_use]
+    #[allow(clippy::too_many_arguments)]
     pub const fn new(
-        name_id: NameId,
+        receiver: Option<NameId>,
+        target: StringId,
         visibility: Visibility,
         uri_id: UriId,
         offset: Offset,
@@ -732,7 +741,8 @@ impl ConstantVisibilityDefinition {
         lexical_nesting_id: Option<DefinitionId>,
     ) -> Self {
         Self {
-            name_id,
+            receiver,
+            target,
             visibility,
             uri_id,
             offset,
@@ -744,12 +754,17 @@ impl ConstantVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.target))
     }
 
     #[must_use]
-    pub fn name_id(&self) -> &NameId {
-        &self.name_id
+    pub fn receiver(&self) -> &Option<NameId> {
+        &self.receiver
+    }
+
+    #[must_use]
+    pub fn target(&self) -> &StringId {
+        &self.target
     }
 
     #[must_use]
@@ -782,7 +797,7 @@ impl ConstantVisibilityDefinition {
         &self.flags
     }
 }
-assert_mem_size!(ConstantVisibilityDefinition, 56);
+assert_mem_size!(ConstantVisibilityDefinition, 64);
 
 #[derive(Debug)]
 pub struct MethodVisibilityDefinition {
@@ -1024,6 +1039,23 @@ pub enum Parameter {
 }
 assert_mem_size!(Parameter, 24);
 
+impl Parameter {
+    #[must_use]
+    pub fn inner(&self) -> &ParameterStruct {
+        match self {
+            Parameter::RequiredPositional(s)
+            | Parameter::OptionalPositional(s)
+            | Parameter::RestPositional(s)
+            | Parameter::Post(s)
+            | Parameter::RequiredKeyword(s)
+            | Parameter::OptionalKeyword(s)
+            | Parameter::RestKeyword(s)
+            | Parameter::Forward(s)
+            | Parameter::Block(s) => s,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ParameterStruct {
     offset: Offset,

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

@@ -6,7 +6,7 @@ use crate::diagnostic::Diagnostic;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
 use crate::model::declaration::{Ancestor, Declaration, Namespace};
-use crate::model::definitions::{Definition, Receiver};
+use crate::model::definitions::{Definition, MethodVisibilityDefinition, Receiver};
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
@@ -260,10 +260,7 @@ impl Graph {
                 let name = self.names.get(it.name_id()).unwrap();
                 name.str()
             }
-            Definition::ConstantVisibility(it) => {
-                let name = self.names.get(it.name_id()).unwrap();
-                name.str()
-            }
+            Definition::ConstantVisibility(it) => it.target(),
             Definition::MethodVisibility(it) => it.str_id(),
             Definition::GlobalVariable(it) => it.str_id(),
             Definition::InstanceVariable(it) => it.str_id(),
@@ -291,6 +288,16 @@ impl Graph {
         &self.documents
     }
 
+    /// Attaches a diagnostic to the document with the given `uri_id`. The diagnostic clears
+    /// automatically when the document is deleted or re-indexed.
+    ///
+    /// # Panics
+    ///
+    /// Panics if no document is registered for `uri_id`.
+    pub fn add_document_diagnostic(&mut self, uri_id: UriId, diagnostic: Diagnostic) {
+        self.documents.get_mut(&uri_id).unwrap().add_diagnostic(diagnostic);
+    }
+
     /// # Panics
     ///
     /// Panics if the definition is not found
@@ -320,13 +327,21 @@ impl Graph {
             Definition::ConstantAlias(it) => {
                 return self.name_id_to_declaration_id(*it.name_id());
             }
-            Definition::ConstantVisibility(it) => {
-                return self.name_id_to_declaration_id(*it.name_id());
-            }
-            Definition::MethodVisibility(it) => (
-                self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                it.str_id(),
+            Definition::ConstantVisibility(it) => (
+                it.receiver()
+                    .as_ref()
+                    .or_else(|| self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref())),
+                it.target(),
             ),
+            Definition::MethodVisibility(it) => {
+                if it.flags().is_singleton_method_visibility() {
+                    return self.find_singleton_method_visibility_declaration(it);
+                }
+                (
+                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                    it.str_id(),
+                )
+            }
             Definition::GlobalVariable(it) => (
                 self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
                 it.str_id(),
@@ -365,13 +380,15 @@ impl Graph {
                 )
             }
             Definition::MethodAlias(it) => {
-                if let Some(Receiver::SelfReceiver(def_id)) = it.receiver() {
-                    return self.find_self_receiver_declaration(*def_id, *it.new_name_str_id());
-                }
-                (
-                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                    it.new_name_str_id(),
-                )
+                let nesting_name_id = match it.receiver() {
+                    Some(Receiver::SelfReceiver(def_id)) => {
+                        return self.find_self_receiver_declaration(*def_id, *it.new_name_str_id());
+                    }
+                    Some(Receiver::ConstantReceiver(name_id)) => Some(name_id),
+                    None => self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                };
+
+                (nesting_name_id, it.new_name_str_id())
             }
         };
 
@@ -403,6 +420,27 @@ impl Graph {
         None
     }
 
+    /// Looks up the declaration for a singleton method visibility through the singleton class.
+    fn find_singleton_method_visibility_declaration(
+        &self,
+        definition: &MethodVisibilityDefinition,
+    ) -> Option<&DeclarationId> {
+        let nesting_name_id = self.find_enclosing_namespace_name_id(definition.lexical_nesting_id().as_ref());
+        let nesting_declaration_id = match nesting_name_id {
+            Some(name_id) => self.name_id_to_declaration_id(*name_id),
+            None => Some(&*OBJECT_ID),
+        }?;
+        let singleton_id = self
+            .declarations
+            .get(nesting_declaration_id)?
+            .as_namespace()?
+            .singleton_class()?;
+        self.declarations
+            .get(singleton_id)?
+            .as_namespace()?
+            .member(definition.str_id())
+    }
+
     /// Looks up the declaration for a `SelfReceiver` method/alias through the singleton class.
     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)?;
@@ -602,42 +640,50 @@ impl Graph {
         &self.name_dependents
     }
 
-    /// Returns the visibility for a method declaration.
+    /// Returns the visibility for a declaration.
     ///
-    /// Scans the declaration's backing definitions from the end:
-    /// - First `MethodVisibilityDefinition` wins
-    /// - Otherwise, falls back to the latest method-like definition's indexed visibility
-    /// - Returns `None` if the declaration has no definitions with visibility
+    /// For methods, the latest definition wins. For constants, the latest
+    /// `private_constant`/`public_constant` wins, otherwise `Public`.
     #[must_use]
     pub fn visibility(&self, declaration_id: &DeclarationId) -> Option<Visibility> {
         let declaration = self.declarations.get(declaration_id)?;
         let definitions = declaration.definitions();
 
-        // Scan from the end: last visibility directive wins
-        for def_id in definitions.iter().rev() {
-            if let Some(definition) = self.definitions.get(def_id) {
-                match definition {
-                    Definition::MethodVisibility(vis) => return Some(*vis.visibility()),
-                    Definition::Method(method) => return Some(*method.visibility()),
-                    Definition::AttrAccessor(attr) => return Some(*attr.visibility()),
-                    Definition::AttrReader(attr) => return Some(*attr.visibility()),
-                    Definition::AttrWriter(attr) => return Some(*attr.visibility()),
-                    Definition::Class(_)
-                    | Definition::SingletonClass(_)
-                    | Definition::Module(_)
-                    | Definition::Constant(_)
-                    | Definition::ConstantAlias(_)
-                    | Definition::ConstantVisibility(_)
-                    | Definition::GlobalVariable(_)
-                    | Definition::InstanceVariable(_)
-                    | Definition::ClassVariable(_)
-                    | Definition::MethodAlias(_)
-                    | Definition::GlobalVariableAlias(_) => {}
+        match declaration {
+            Declaration::Namespace(Namespace::Class(_) | Namespace::Module(_))
+            | Declaration::Constant(_)
+            | Declaration::ConstantAlias(_) => {
+                for def_id in definitions.iter().rev() {
+                    if let Some(Definition::ConstantVisibility(vis)) = self.definitions.get(def_id) {
+                        return Some(*vis.visibility());
+                    }
                 }
+                Some(Visibility::Public)
+            }
+            Declaration::Method(_) => {
+                for def_id in definitions.iter().rev() {
+                    let Some(definition) = self.definitions.get(def_id) else {
+                        continue;
+                    };
+                    let visibility = match definition {
+                        Definition::MethodVisibility(vis) => Some(*vis.visibility()),
+                        Definition::Method(method) => Some(*method.visibility()),
+                        Definition::AttrAccessor(attr) => Some(*attr.visibility()),
+                        Definition::AttrReader(attr) => Some(*attr.visibility()),
+                        Definition::AttrWriter(attr) => Some(*attr.visibility()),
+                        _ => None,
+                    };
+                    if visibility.is_some() {
+                        return visibility;
+                    }
+                }
+                None
             }
+            Declaration::Namespace(Namespace::SingletonClass(_) | Namespace::Todo(_))
+            | Declaration::GlobalVariable(_)
+            | Declaration::InstanceVariable(_)
+            | Declaration::ClassVariable(_) => None,
         }
-
-        None
     }
 
     /// Drains the accumulated work items, returning them for use by the resolver.
@@ -645,7 +691,7 @@ impl Graph {
         std::mem::take(&mut self.pending_work)
     }
 
-    fn push_work(&mut self, unit: Unit) {
+    pub(crate) fn push_work(&mut self, unit: Unit) {
         self.pending_work.push(unit);
     }
 
@@ -2398,6 +2444,34 @@ mod incremental_resolution_tests {
         }
     }
 
+    /// Compares incremental resolution against a fresh index at the declaration-ID level.
+    ///
+    /// This is a broad consistency check: it catches both stale declarations left
+    /// behind by incremental invalidation and declarations that incremental
+    /// resolution failed to recreate.
+    fn assert_declaration_ids_match(incremental: &GraphTest, fresh: &GraphTest) {
+        let extras: Vec<_> = incremental
+            .graph()
+            .declarations()
+            .iter()
+            .filter(|(id, _)| !fresh.graph().declarations().contains_key(id))
+            .map(|(_, d)| format!("{} ({})", d.name(), d.kind()))
+            .collect();
+
+        let missing: Vec<_> = fresh
+            .graph()
+            .declarations()
+            .iter()
+            .filter(|(id, _)| !incremental.graph().declarations().contains_key(id))
+            .map(|(_, d)| format!("{} ({})", d.name(), d.kind()))
+            .collect();
+
+        assert!(
+            extras.is_empty() && missing.is_empty(),
+            "Declaration mismatch:\n  Extra: {extras:?}\n  Missing: {missing:?}"
+        );
+    }
+
     #[test]
     fn new_namespace_shadowing_include_target_invalidates_references() {
         let mut context = GraphTest::new();
@@ -3772,6 +3846,162 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(context, "Parent::Target::<Target>");
     }
 
+    #[test]
+    fn singleton_definition_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "class << Foo; def bar; end; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo");
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>");
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_does_not_exist!(incremental, "Object#bar()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "class << Foo; def bar; end; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+    }
+
+    #[test]
+    fn explicit_singleton_method_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "def Foo.bar; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#bar()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "def Foo.bar; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+    }
+
+    #[test]
+    fn explicit_singleton_method_ivar_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "def Foo.bar; @x = 1; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#@x");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#@x");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "def Foo.bar; @x = 1; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#@x");
+    }
+
+    #[test]
+    fn constant_receiver_method_alias_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///alias.rb", "Foo.alias_method :new_name, :old_name");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo#new_name()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo#new_name()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///alias.rb", "Foo.alias_method :new_name, :old_name");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo#new_name()");
+    }
+
+    #[test]
+    fn singleton_body_method_alias_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "class << Foo; def old; end; alias new old; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>#old()");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#new()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#old()");
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#new()");
+        assert_declaration_does_not_exist!(incremental, "Object#old()");
+        assert_declaration_does_not_exist!(incremental, "Object#new()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "class << Foo; def old; end; alias new old; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#new()");
+    }
+
+    #[test]
+    fn singleton_body_ivar_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "class << Foo; @bar = 1; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+        assert_declaration_does_not_exist!(incremental, "Object::<Object>#@bar");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "class << Foo; @bar = 1; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+    }
+
     #[test]
     fn no_duplicate_definition_on_identical_file_delete_readd() {
         let source = "class Foo; def self.run; end; def run; end; end";