rubydex 0.1.0.beta13 → 0.1.0.beta14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 922611abae468890ba5fcf77e365aba7ac79754c5db93abeec4ad67fb84469a0
-  data.tar.gz: 75ccad3efb46e07f582e732452be8d388183ee2030e2569c1a19a07844ab20f8
+  metadata.gz: 55c47ced758d8aff486a445a0c15a1ffe6525b5d2ee59fea8d38be40bc791207
+  data.tar.gz: 9e73f9244f197ed1b062f475ddc077b25f1dd0a5d8c29de430c7b256b20c380e
 SHA512:
-  metadata.gz: 4810b81cca5c1aceb7546f1e75f348217ae8b0f2b9559e315b58e96eb8a62ca5603c68ae863da43272830feef452389b390c1b2786cfc3ff0944dc0e1096acb2
-  data.tar.gz: e119905f38a21842a543053e0218cd29559c17865e81485fd7f54d74f43782f445902b166d1cd20c28dcd4b5bdf39533122f8cff38a81201f6c25868bb78798f
+  metadata.gz: 50444ddd1ca5576961316b2c8db705a872eaf658366587d11f9cc2860b2f97f517257ffbcc51bf9fbfa0036e436b5fe338479431c90e285ad155048616f77897
+  data.tar.gz: 856b302c492ccc0ba74a4ea1dc5c2fc993ba43a47a0f635ee005af764ae39c1be61a50fcc79f8b151c1b20e77a7e0b719115fe3427fed880ed0f0cbdd47fed45

data/ext/rubydex/declaration.c

@@ -407,6 +407,28 @@ static VALUE rdxr_variable_declaration_references(VALUE self) {
     return rb_ary_new();
 }
 
+// ConstantAlias#target -> Declaration?
+// Returns the first resolved target declaration for this constant alias, or nil if none of its definitions resolved to
+// a target
+static VALUE rdxr_constant_alias_target(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const CDeclaration *decl = rdx_constant_alias_target(graph, data->id);
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
 void rdxi_initialize_declaration(VALUE mRubydex) {
     cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
     cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
@@ -440,6 +462,7 @@ void rdxi_initialize_declaration(VALUE mRubydex) {
     // Constant and ConstantAlias have constant references
     rb_define_method(cConstant, "references", rdxr_constant_declaration_references, 0);
     rb_define_method(cConstantAlias, "references", rdxr_constant_declaration_references, 0);
+    rb_define_method(cConstantAlias, "target", rdxr_constant_alias_target, 0);
 
     // Method has method references
     rb_define_method(cMethod, "references", rdxr_method_declaration_references, 0);

data/ext/rubydex/extconf.rb

@@ -86,11 +86,15 @@ copy_dylib_commands = if Gem.win_platform?
   ""
 elsif RUBY_PLATFORM.include?("darwin")
   src_dylib = target_dir.join("librubydex_sys.dylib")
-  "\t$(COPY) #{src_dylib} #{lib_dir}"
+  dst_dylib = lib_dir.join("librubydex_sys.dylib")
+  # Unlink before copy so the new dylib gets a fresh inode. Overwriting in place while another process
+  # (e.g. the Ruby LSP) has the old dylib mmap'd triggers a macOS code-signing SIGKILL on its next page fault.
+  "\t$(Q)$(RM) #{dst_dylib}\n\t$(COPY) #{src_dylib} #{lib_dir}"
 else
   # Linux
   src_dylib = target_dir.join("librubydex_sys.so")
-  "\t$(COPY) #{src_dylib} #{lib_dir}"
+  dst_dylib = lib_dir.join("librubydex_sys.so")
+  "\t$(Q)$(RM) #{dst_dylib}\n\t$(COPY) #{src_dylib} #{lib_dir}"
 end
 
 rust_srcs = Dir.glob("#{root_dir}/**/*.rs").reject { |path| path.include?("rust/target") }

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.1.0.beta13"
+  VERSION = "0.1.0.beta14"
 end

data/rbi/rubydex.rbi

@@ -76,6 +76,9 @@ end
 class Rubydex::ConstantAlias < Rubydex::Declaration
   sig { returns(T::Enumerable[Rubydex::ConstantReference]) }
   def references; end
+
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def target; end
 end
 
 class Rubydex::ClassVariable < Rubydex::Declaration

data/rust/rubydex/src/diagnostic.rs

@@ -107,4 +107,5 @@ rules! {
     InvalidMethodVisibility;
 
     // Resolution
+    UndefinedMethodVisibilityTarget;
 }

data/rust/rubydex/src/indexing/ruby_indexer.rs

@@ -1507,9 +1507,10 @@ impl Visit<'_> for RubyIndexer<'_> {
         };
 
         let string_id = self.local_graph.intern_string(singleton_class_name);
+        let nesting = self.current_lexical_scope_name_id();
         let name_id = self
             .local_graph
-            .add_name(Name::new(string_id, ParentScope::Attached(attached_target), None));
+            .add_name(Name::new(string_id, ParentScope::Attached(attached_target), nesting));
 
         let definition = Definition::SingletonClass(Box::new(SingletonClassDefinition::new(
             name_id,

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

@@ -14,6 +14,7 @@ use crate::model::ids::{ConstantReferenceId, DeclarationId, DefinitionId, Method
 use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
+use crate::model::visibility::Visibility;
 use crate::stats;
 
 /// An entity whose validity depends on a particular `NameId`.
@@ -601,6 +602,44 @@ impl Graph {
         &self.name_dependents
     }
 
+    /// Returns the visibility for a method 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
+    #[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(_) => {}
+                }
+            }
+        }
+
+        None
+    }
+
     /// Drains the accumulated work items, returning them for use by the resolver.
     pub fn take_pending_work(&mut self) -> Vec<Unit> {
         std::mem::take(&mut self.pending_work)
@@ -2234,14 +2273,14 @@ mod tests {
         assert_eq!(13, context.graph().constant_references.len());
         assert_eq!(2, context.graph().method_references.len());
         assert_eq!(2, context.graph().documents.len());
-        assert_eq!(19, context.graph().names.len());
+        assert_eq!(20, context.graph().names.len());
         assert_eq!(47, context.graph().strings.len());
         context.index_uri("file:///foo.rb", source);
         assert_eq!(49, context.graph().definitions.len());
         assert_eq!(13, context.graph().constant_references.len());
         assert_eq!(2, context.graph().method_references.len());
         assert_eq!(2, context.graph().documents.len());
-        assert_eq!(19, context.graph().names.len());
+        assert_eq!(20, context.graph().names.len());
         assert_eq!(47, context.graph().strings.len());
     }
 

data/rust/rubydex/src/query.rs

@@ -897,7 +897,7 @@ mod tests {
         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), 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(name_id),

data/rust/rubydex/src/resolution.rs

@@ -3,6 +3,7 @@ use std::{
     hash::BuildHasher,
 };
 
+use crate::diagnostic::{Diagnostic, Rule};
 use crate::model::{
     built_in::{BASIC_OBJECT_ID, CLASS_ID, KERNEL_ID, MODULE_ID, OBJECT_ID},
     declaration::{
@@ -272,6 +273,8 @@ impl<'a> Resolver<'a> {
     /// Handle other definitions that don't require resolution, but need to have their declarations and membership created
     #[allow(clippy::too_many_lines)]
     fn handle_remaining_definitions(&mut self, other_ids: Vec<DefinitionId>) {
+        let mut method_visibility_ids = Vec::new();
+
         for id in other_ids {
             match self.graph.definitions().get(&id).unwrap() {
                 Definition::Method(method_definition) => {
@@ -538,8 +541,8 @@ impl<'a> Resolver<'a> {
                 Definition::ConstantVisibility(_constant_visibility) => {
                     // TODO
                 }
-                Definition::MethodVisibility(_method_visibility) => {
-                    // TODO
+                Definition::MethodVisibility(_) => {
+                    method_visibility_ids.push(id);
                 }
                 Definition::Class(_)
                 | Definition::SingletonClass(_)
@@ -550,6 +553,91 @@ impl<'a> Resolver<'a> {
                 }
             }
         }
+
+        self.resolve_method_visibilities(method_visibility_ids);
+    }
+
+    /// Resolves retroactive method visibility changes (`private :foo`, `protected :foo`, `public :foo`).
+    ///
+    /// Runs as a second pass after all methods/attrs are declared, so `private :bar` works
+    /// regardless of whether `def bar` appeared before or after it in source.
+    fn resolve_method_visibilities(&mut self, visibility_ids: Vec<DefinitionId>) {
+        let mut pending_work = Vec::new();
+
+        for id in visibility_ids {
+            let Definition::MethodVisibility(method_visibility) = self.graph.definitions().get(&id).unwrap() else {
+                unreachable!()
+            };
+
+            let str_id = *method_visibility.str_id();
+            let uri_id = *method_visibility.uri_id();
+            let offset = method_visibility.offset().clone();
+            let lexical_nesting_id = *method_visibility.lexical_nesting_id();
+
+            let Some(owner_id) = self.resolve_lexical_owner(lexical_nesting_id) else {
+                continue;
+            };
+
+            let Some(Declaration::Namespace(namespace)) = self.graph.declarations().get(&owner_id) else {
+                continue;
+            };
+
+            let mut visibility_applied = false;
+            let mut has_partial = false;
+
+            for ancestor in namespace.ancestors() {
+                match ancestor {
+                    Ancestor::Complete(ancestor_id) => {
+                        let has_member = self
+                            .graph
+                            .declarations()
+                            .get(ancestor_id)
+                            .and_then(|decl| decl.as_namespace())
+                            .and_then(|ns| ns.member(&str_id))
+                            .is_some();
+
+                        if has_member {
+                            // Direct member: `create_declaration`'s fully qualified name dedup attaches
+                            // this visibility definition to the existing method declaration.
+                            // Inherited: a new child-owned declaration is created.
+                            self.create_declaration(str_id, id, owner_id, |name| {
+                                Declaration::Method(Box::new(MethodDeclaration::new(name, owner_id)))
+                            });
+                            visibility_applied = true;
+                            break;
+                        }
+                    }
+                    Ancestor::Partial(_) => has_partial = true,
+                }
+            }
+
+            if visibility_applied {
+                continue;
+            }
+
+            if has_partial {
+                // Method might exist on an unresolved ancestor — requeue for retry.
+                pending_work.push(Unit::Definition(id));
+            } else {
+                // Ancestors are fully resolved — method definitively doesn't exist.
+                let method_name = self.graph.strings().get(&str_id).unwrap().as_str().to_string();
+                let owner_name = self.graph.declarations().get(&owner_id).unwrap().name().to_string();
+                let diagnostic = Diagnostic::new(
+                    Rule::UndefinedMethodVisibilityTarget,
+                    uri_id,
+                    offset,
+                    format!("undefined method `{method_name}` for visibility change in `{owner_name}`"),
+                );
+                self.graph
+                    .declarations_mut()
+                    .get_mut(&owner_id)
+                    .unwrap()
+                    .add_diagnostic(diagnostic);
+            }
+        }
+
+        // Must extend work here so incremental resolution can resolve previously unresolved visibility operations
+        self.graph.extend_work(pending_work);
     }
 
     fn create_declaration<F>(