rubydex 0.1.0.beta14 → 0.2.1

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

@@ -155,8 +155,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 +711,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 +723,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 +735,8 @@ impl ConstantVisibilityDefinition {
         lexical_nesting_id: Option<DefinitionId>,
     ) -> Self {
         Self {
-            name_id,
+            receiver,
+            target,
             visibility,
             uri_id,
             offset,
@@ -744,12 +748,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 +791,7 @@ impl ConstantVisibilityDefinition {
         &self.flags
     }
 }
-assert_mem_size!(ConstantVisibilityDefinition, 56);
+assert_mem_size!(ConstantVisibilityDefinition, 64);
 
 #[derive(Debug)]
 pub struct MethodVisibilityDefinition {

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

@@ -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,9 +327,12 @@ 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::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) => (
                 self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
                 it.str_id(),
@@ -602,42 +612,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 +663,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 +2416,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 +3818,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";