rubydex 0.1.0.beta13 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 922611abae468890ba5fcf77e365aba7ac79754c5db93abeec4ad67fb84469a0
-  data.tar.gz: 75ccad3efb46e07f582e732452be8d388183ee2030e2569c1a19a07844ab20f8
+  metadata.gz: 62ff27bd44d2fb24baaea47fbead5e90a99b129d77fb189e9410ba7a04b6a1df
+  data.tar.gz: 9acd6049e9e44db280b8a6665b7ac6772703d28e89c3b016b8ccedd133fc1de6
 SHA512:
-  metadata.gz: 4810b81cca5c1aceb7546f1e75f348217ae8b0f2b9559e315b58e96eb8a62ca5603c68ae863da43272830feef452389b390c1b2786cfc3ff0944dc0e1096acb2
-  data.tar.gz: e119905f38a21842a543053e0218cd29559c17865e81485fd7f54d74f43782f445902b166d1cd20c28dcd4b5bdf39533122f8cff38a81201f6c25868bb78798f
+  metadata.gz: b1d3b9c88293608e2cce5e7d30b8553ca02bb9d1026de21a362f93fa6af530f566f2858fe1db38eb8b17f4280b71d5af4deddff07ba09d5068430126c130389e
+  data.tar.gz: 9d552f809c4d9a1a71b4301fa5622d2db60bb3fa4aa92e03329c62034483d2225dbd5bc0d87b2202d16e59653bdb742bc13dd831940a1d41607f79def20b6b34

data/exe/rdx

@@ -2,11 +2,12 @@
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
 require "optparse"
 
-OptionParser.new do |parser|
-  parser.banner = "Usage: [path1, path2]"
+options = {}
 
+OptionParser.new do |parser|
   parser.on("--version", "Print the gem's version") do
     require "rubydex/version"
     puts "v#{Rubydex::VERSION}"
@@ -17,31 +18,34 @@ OptionParser.new do |parser|
     puts parser
     exit
   end
+
+  parser.on("-i", "--interactive", "Open an interactive session with a populated graph for the current workspace") do
+    options[:interactive] = true
+  end
 end.parse!
 
 require "rubydex"
 
-workspace_path = ARGV.first
-
-# If a workspace path is passed, we need to ensure that Bundler is setup in that context so that we find the
-# dependencies for that project
-if workspace_path
-  gemfile_path = File.join(workspace_path, "Gemfile")
-
-  if File.exist?(gemfile_path)
-    ENV["BUNDLE_GEMFILE"] = gemfile_path
-
-    begin
-      Bundler.setup
-    rescue Bundler::BundlerError => e
-      $stderr.puts(<<~MESSAGE)
-        Bundle setup failed for #{gemfile_path}. Indexing of dependencies may be partial
-        Error:
-          #{e.message}
-      MESSAGE
-    end
-  end
+def __with_timer(message, &block)
+  print(message)
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+  block.call
+  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+  puts " finished in #{duration.round(2)}ms"
 end
 
-graph = Rubydex::Graph.new(workspace_path: workspace_path)
-graph.index_workspace
+graph = Rubydex::Graph.new
+__with_timer("Indexing workspace...") { graph.index_workspace }
+__with_timer("Resolving graph...") { graph.resolve }
+
+if options[:interactive]
+  begin
+    require "irb"
+    IRB.setup(nil)
+    IRB.conf[:IRB_NAME] = "rubydex"
+    workspace = IRB::WorkSpace.new(binding)
+    IRB::Irb.new(workspace).run(IRB.conf)
+  rescue LoadError
+    abort("Interactive mode requires `irb` to be in the bundle")
+  end
+end

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") }
@@ -137,10 +141,12 @@ end
 
 File.write("Makefile", new_makefile)
 
-begin
-  require "extconf_compile_commands_json"
+if developing_rubydex
+  begin
+    require "extconf_compile_commands_json"
 
-  ExtconfCompileCommandsJson.generate!
-  ExtconfCompileCommandsJson.symlink!
-rescue LoadError # rubocop:disable Lint/SuppressedException
+    ExtconfCompileCommandsJson.generate!
+    ExtconfCompileCommandsJson.symlink!
+  rescue LoadError # rubocop:disable Lint/SuppressedException
+  end
 end

data/ext/rubydex/graph.c

@@ -303,6 +303,24 @@ static VALUE rdxr_graph_method_references(VALUE self) {
     return self;
 }
 
+// Graph#document: (String uri) -> Document?
+// Returns the Document for the given URI, or nil if it doesn't exist.
+static VALUE rdxr_graph_document(VALUE self, VALUE uri) {
+    Check_Type(uri, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    const uint64_t *uri_id = rdx_graph_get_document(graph, StringValueCStr(uri));
+
+    if (uri_id == NULL) {
+        return Qnil;
+    }
+
+    VALUE argv[] = {self, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 // Graph#delete_document: (String uri) -> Document?
 // Deletes a document and all of its definitions from the graph.
 // Returns the removed Document or nil if it doesn't exist.
@@ -676,6 +694,7 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_alloc_func(cGraph, rdxr_graph_alloc);
     rb_define_method(cGraph, "index_all", rdxr_graph_index_all, 1);
     rb_define_method(cGraph, "index_source", rdxr_graph_index_source, 3);
+    rb_define_method(cGraph, "document", rdxr_graph_document, 1);
     rb_define_method(cGraph, "delete_document", rdxr_graph_delete_document, 1);
     rb_define_method(cGraph, "resolve", rdxr_graph_resolve, 0);
     rb_define_method(cGraph, "resolve_constant", rdxr_graph_resolve_constant, 2);

data/ext/rubydex/reference.c

@@ -75,6 +75,28 @@ static VALUE rdxr_method_reference_location(VALUE self) {
     return location;
 }
 
+// MethodReference#receiver -> Rubydex::Declaration?
+// Returns the resolved declaration for the receiver of the method call. Returns nil when the receiver is not a
+// tracked constant or cannot be resolved.
+static VALUE rdxr_method_reference_receiver(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 struct CDeclaration *decl = rdx_method_reference_receiver_declaration(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);
+}
+
 // ResolvedConstantReference#declaration -> Declaration
 static VALUE rdxr_resolved_constant_reference_declaration(VALUE self) {
     HandleData *data;
@@ -120,4 +142,5 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     rb_define_method(cMethodReference, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cMethodReference, "name", rdxr_method_reference_name, 0);
     rb_define_method(cMethodReference, "location", rdxr_method_reference_location, 0);
+    rb_define_method(cMethodReference, "receiver", rdxr_method_reference_receiver, 0);
 }

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.1.0.beta13"
+  VERSION = "0.2.0"
 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
@@ -256,6 +259,9 @@ class Rubydex::Graph
   sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
   def delete_document(uri); end
 
+  sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
+  def document(uri); end
+
   sig { returns(T::Array[Rubydex::Diagnostic]) }
   def diagnostics; end
 
@@ -412,6 +418,9 @@ class Rubydex::MethodReference < Rubydex::Reference
 
   sig { returns(String) }
   def name; end
+
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def receiver; end
 end
 
 class Rubydex::Reference

data/rust/rubydex/src/diagnostic.rs

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

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

@@ -234,6 +234,7 @@ impl<'a> RubyIndexer<'a> {
                     Offset::from_prism_location(&name_loc),
                     str_id,
                 )));
+                self.visit(&opt_param.value());
             }
 
             if let Some(rest) = parameters_list.rest() {
@@ -276,6 +277,7 @@ impl<'a> RubyIndexer<'a> {
                         let str_id = self.local_graph.intern_string(self.offset_to_string(&offset));
 
                         parameters.push(Parameter::OptionalKeyword(ParameterStruct::new(offset, str_id)));
+                        self.visit(&optional.value());
                     }
                     _ => {}
                 }
@@ -1507,9 +1509,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/indexing/ruby_indexer_tests.rs

@@ -4060,6 +4060,19 @@ mod constant_reference_tests {
         );
     }
 
+    #[test]
+    fn index_unresolved_constant_references_in_default_values() {
+        let context = index_source({
+            "
+            def foo(a = C1, b = C2::C3); end
+            def bar(a: C4, b: C5::C6); end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_constant_references_eq!(&context, ["C1", "C2", "C3", "C4", "C5", "C6"]);
+    }
+
     #[test]
     fn index_constant_path_and_write_visits_value() {
         let context = index_source({

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