rubydex 0.2.5 → 0.2.7

data/rust/rubydex/src/resolution.rs

@@ -375,10 +375,16 @@ impl<'a> Resolver<'a> {
                         Definition::Method(method) => {
                             if let Some(receiver) = method.receiver() {
                                 let receiver_decl_id = match receiver {
-                                    Receiver::SelfReceiver(def_id) => *self
-                                        .graph
-                                        .definition_id_to_declaration_id(*def_id)
-                                        .expect("SelfReceiver definition should have a declaration"),
+                                    Receiver::SelfReceiver(def_id) => {
+                                        let Some(&receiver_decl_id) =
+                                            self.graph.definition_id_to_declaration_id(*def_id)
+                                        else {
+                                            self.graph.push_work(Unit::Definition(id));
+                                            continue;
+                                        };
+
+                                        receiver_decl_id
+                                    }
                                     Receiver::ConstantReceiver(name_id) => {
                                         let Some(receiver_decl_id) = self.resolve_constant_receiver(*name_id, id)
                                         else {
@@ -513,13 +519,15 @@ impl<'a> Resolver<'a> {
                     let new_name_str_id = *alias.new_name_str_id();
                     let owner_id = match alias.receiver() {
                         Some(Receiver::SelfReceiver(def_id)) => {
-                            let decl_id = *self
-                                .graph
-                                .definition_id_to_declaration_id(*def_id)
-                                .expect("SelfReceiver definition should have a declaration");
+                            let Some(&decl_id) = self.graph.definition_id_to_declaration_id(*def_id) else {
+                                self.graph.push_work(Unit::Definition(id));
+                                continue;
+                            };
+
                             let Some(owner_id) = self.get_or_create_singleton_class(decl_id, true) else {
                                 continue;
                             };
+
                             owner_id
                         }
                         Some(Receiver::ConstantReceiver(name_id)) => {
@@ -702,18 +710,8 @@ impl<'a> Resolver<'a> {
                     offset,
                     format!("undefined method `{owner_name}#{method_name}` for visibility change"),
                 );
-                if is_singleton {
-                    // Document-scoped: the singleton class may be synthetic (created by this
-                    // visibility resolution) and won't be cleaned up on file delete, so attaching
-                    // the diagnostic to the declaration would leave it orphaned.
-                    self.graph.add_document_diagnostic(uri_id, diagnostic);
-                } else {
-                    self.graph
-                        .declarations_mut()
-                        .get_mut(&owner_id)
-                        .unwrap()
-                        .add_diagnostic(diagnostic);
-                }
+
+                self.graph.add_document_diagnostic(uri_id, diagnostic);
             }
         }
 

data/rust/rubydex/src/resolution_tests.rs

@@ -4674,6 +4674,138 @@ mod promotability_tests {
         assert_declaration_does_not_exist!(context, "Foo::<Foo>");
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
     }
+
+    #[test]
+    fn ivar_defined_inside_of_undefined_alias_namespace() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+
+            class Aliased::Inner
+              def self.run
+                @ivar = 1
+              end
+            end
+            "
+        });
+
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // Since we have no idea what `Aliased` is, then we cannot create `Inner`, `run()` or `@ivar` declarations
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#run()");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#@ivar");
+    }
+
+    #[test]
+    fn ivar_inside_undefined_alias_namespace_recovers_when_target_is_defined() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+
+            class Aliased::Inner
+              def self.run
+                @ivar = 1
+              end
+            end
+            "
+        });
+        context.resolve();
+
+        // Nothing can be placed yet: `Aliased` aliases a constant that does not exist.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+
+        // A later edit defines the alias target. The instance variable must not have been
+        // dropped permanently: it should be remembered and placed once its owner exists.
+        context.index_uri("file:///target.rb", {
+            r"
+            module Undefined
+            end
+            "
+        });
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // `Aliased` now resolves to `Undefined`, so the nested declarations materialize under it,
+        // including the previously-deferred instance variable.
+        assert_declaration_kind_eq!(context, "Undefined::Inner", "Class");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>", "SingletonClass");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#run()", "Method");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#@ivar", "InstanceVariable");
+    }
+
+    #[test]
+    fn self_method_alias_defined_inside_of_undefined_alias_namespace() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+            "
+        });
+        // RBS singleton method alias (`alias self.x self.y`) nested under the undefined-alias namespace.
+        context.index_rbs_uri(
+            "file:///alias.rbs",
+            r"
+            class Aliased::Inner
+              def self.run: () -> void
+              alias self.execute self.run
+            end
+            ",
+        );
+
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // Since we have no idea what `Aliased` is, none of the nested declarations (including the
+        // singleton method alias) can be created.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#run()");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#execute()");
+    }
+
+    #[test]
+    fn self_method_alias_inside_undefined_alias_namespace_recovers_when_target_is_defined() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+            "
+        });
+        context.index_rbs_uri(
+            "file:///alias.rbs",
+            r"
+            class Aliased::Inner
+              def self.run: () -> void
+              alias self.execute self.run
+            end
+            ",
+        );
+        context.resolve();
+
+        // Nothing can be placed yet: `Aliased` aliases a constant that does not exist.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+
+        // A later edit defines the alias target. The singleton method alias must not have been
+        // dropped permanently: it should be remembered and placed once its owner exists.
+        context.index_uri("file:///target.rb", {
+            r"
+            module Undefined
+            end
+            "
+        });
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // `Aliased` now resolves to `Undefined`, so the nested declarations materialize under it,
+        // including the previously-deferred singleton method alias.
+        assert_declaration_kind_eq!(context, "Undefined::Inner", "Class");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>", "SingletonClass");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#run()", "Method");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#execute()", "Method");
+    }
 }
 
 mod rbs_tests {

data/rust/rubydex/tests/cli.rs

@@ -1,7 +1,6 @@
 use assert_cmd::{assert::Assert, prelude::*};
 use predicates::prelude::*;
-use regex::Regex;
-use rubydex::test_utils::{normalize_indentation, with_context};
+use rubydex::test_utils::with_context;
 use std::process::Command;
 
 fn rdx_cmd(args: &[&str]) -> Command {
@@ -21,7 +20,7 @@ fn prints_help() {
         .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
         .stdout(predicate::str::contains("Usage:"))
         .stdout(predicate::str::contains("--stats"))
-        .stdout(predicate::str::contains("--visualize"))
+        .stdout(predicate::str::contains("--dot"))
         .stdout(predicate::str::contains("--stop-after"));
 }
 
@@ -68,68 +67,25 @@ fn prints_index_metrics() {
     });
 }
 
-fn normalize_visualization_output(output: &str) -> String {
-    let def_re = Regex::new(r"def_-?[a-f0-9]+").unwrap();
-    let uri_re = Regex::new(r#"file://[^"]+/([^/"]+\.rb)"#).unwrap();
-
-    let normalized = def_re.replace_all(output, "def_<ID>");
-    uri_re.replace_all(&normalized, "file://<PATH>/$1").to_string()
-}
-
 #[test]
-fn visualize_simple_class() {
+fn dot_flag() {
     with_context(|context| {
         context.write("simple.rb", "class SimpleClass\nend\n");
 
-        let output = rdx_cmd(&[context.absolute_path().to_str().unwrap(), "--visualize"])
-            .output()
-            .unwrap();
-
-        assert!(output.status.success());
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let normalized = normalize_visualization_output(&stdout);
-
-        let expected = normalize_indentation({
-            r#"
-            digraph {
-                rankdir=TB;
-
-                "Name:BasicObject" [label="BasicObject",shape=hexagon];
-                "Name:BasicObject" -> "def_<ID>" [dir=both];
-                "Name:Class" [label="Class",shape=hexagon];
-                "Name:Class" -> "def_<ID>" [dir=both];
-                "Name:Kernel" [label="Kernel",shape=hexagon];
-                "Name:Kernel" -> "def_<ID>" [dir=both];
-                "Name:Module" [label="Module",shape=hexagon];
-                "Name:Module" -> "def_<ID>" [dir=both];
-                "Name:Object" [label="Object",shape=hexagon];
-                "Name:Object" -> "def_<ID>" [dir=both];
-                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
-                "Name:SimpleClass" -> "def_<ID>" [dir=both];
-
-                "def_<ID>" [label="Class(BasicObject)",shape=ellipse];
-                "def_<ID>" [label="Class(Class)",shape=ellipse];
-                "def_<ID>" [label="Class(Module)",shape=ellipse];
-                "def_<ID>" [label="Class(Object)",shape=ellipse];
-                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
-                "def_<ID>" [label="Module(Kernel)",shape=ellipse];
-
-                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
-                "def_<ID>" -> "file://<PATH>/simple.rb";
-                "rubydex:built-in" [label="rubydex:built-in",shape=box];
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-
-            }
-
-            "#
-        });
-
-        assert_eq!(normalized, expected);
+        rdx(&[context.absolute_path().to_str().unwrap(), "--dot"])
+            .success()
+            .stdout(predicate::str::contains("digraph rubydex"))
+            // Document node
+            .stdout(predicate::str::contains("Document"))
+            .stdout(predicate::str::contains("simple.rb"))
+            // Definition node
+            .stdout(predicate::str::contains("ClassDef"))
+            .stdout(predicate::str::contains("SimpleClass"))
+            // Declaration node
+            .stdout(predicate::str::contains("ClassDecl"))
+            // Edges
+            .stdout(predicate::str::contains("defines"))
+            .stdout(predicate::str::contains("declares"));
     });
 }
 

data/rust/rubydex-mcp/Cargo.toml

@@ -1,16 +1,22 @@
 [package]
 name = "rubydex-mcp"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
+description = "MCP server exposing Rubydex semantic Ruby code intelligence tools."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "mcp", "static-analysis"]
+categories = ["development-tools"]
 
 [[bin]]
 name = "rubydex_mcp"
 path = "src/main.rs"
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 clap = { version = "4.5.16", features = ["derive"] }
 rmcp = { version = "1.4", features = ["server", "macros", "transport-io", "schemars"] }
 tokio = { version = "1", features = ["macros", "rt", "io-std"] }
@@ -20,7 +26,7 @@ schemars = "1"
 url = "2"
 
 [dev-dependencies]
-rubydex = { path = "../rubydex", features = ["test_utils"] }
+rubydex = { version = "0.2.6", path = "../rubydex", features = ["test_utils"] }
 assert_cmd = "2.0"
 serde_json = "1"
 

data/rust/rubydex-sys/Cargo.toml

@@ -1,14 +1,21 @@
 [package]
 name = "rubydex-sys"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
+rust-version = "1.89.0"
 license = "MIT"
+description = "C FFI bindings for the Rubydex Ruby code indexing engine."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "ffi", "static-analysis"]
+categories = ["development-tools", "external-ffi-bindings"]
 
 [lib]
 crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 libc = "0.2.174"
 url = "2.5.4"
 line-index = "0.1.2"

data/rust/rubydex-sys/src/definition_api.rs

@@ -7,6 +7,7 @@ use crate::reference_api::CConstantReference;
 use libc::c_char;
 use rubydex::model::definitions::{Definition, Mixin};
 use rubydex::model::ids::DefinitionId;
+use rubydex::query::AliasResolutionError;
 use std::ffi::CString;
 use std::ptr;
 
@@ -346,8 +347,8 @@ pub unsafe extern "C" fn rdx_definition_is_deprecated(pointer: GraphPointer, def
 }
 
 /// Returns a newly allocated `Location` for the name portion of a definition id.
-/// For class, module, and singleton class definitions, this returns the location of just
-/// the name (e.g., "Bar" in `class Foo::Bar`).
+/// For class, module, singleton class, and method definitions, this returns the location of just
+/// the name (e.g., "Bar" in `class Foo::Bar`, or "foo" in `def foo`).
 /// For other definition types, returns NULL.
 /// Caller must free the returned pointer with `rdx_location_free`.
 ///
@@ -491,3 +492,72 @@ pub unsafe extern "C" fn rdx_definition_mixins(pointer: GraphPointer, definition
         MixinsIter::new(entries.into_boxed_slice())
     })
 }
+
+/// Status of a `MethodAliasDefinition#target` resolution.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CMethodAliasResolution {
+    /// The alias chain resolved successfully; `declaration` is valid.
+    Resolved = 0,
+    /// The chain could not be resolved because the target name does not exist on the owner, or the owner itself was
+    /// never resolved. Treated as `nil` on the Ruby side.
+    NotFound = 1,
+    /// The alias chain forms a cycle. Surfaced as a `Rubydex::AliasCycleError` on the Ruby side.
+    Cycle = 2,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CMethodAliasTargetResult {
+    pub status: CMethodAliasResolution,
+    pub declaration: *const CDeclaration,
+}
+
+/// Resolves a `MethodAliasDefinition` to its target method declaration via `query::follow_method_alias` and reports the
+/// outcome as a tagged status. The `declaration` pointer is non-null only when `status == Resolved`; the caller is
+/// responsible for freeing it with `free_c_declaration`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id for a `MethodAliasDefinition`.
+///
+/// # Panics
+/// Panics on graph inconsistencies (the definition is not a method alias, or the alias resolved to a non-method
+/// declaration).
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_alias_definition_target(
+    pointer: GraphPointer,
+    definition_id: u64,
+) -> CMethodAliasTargetResult {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+
+        match rubydex::query::follow_method_alias(graph, def_id) {
+            Ok(target_id) => {
+                let target_decl = graph
+                    .declarations()
+                    .get(&target_id)
+                    .expect("target declaration must exist");
+                let boxed = Box::new(CDeclaration::from_declaration(target_id, target_decl));
+
+                CMethodAliasTargetResult {
+                    status: CMethodAliasResolution::Resolved,
+                    declaration: Box::into_raw(boxed).cast_const(),
+                }
+            }
+            Err(AliasResolutionError::TargetNotFound | AliasResolutionError::UnresolvedOwner) => {
+                CMethodAliasTargetResult {
+                    status: CMethodAliasResolution::NotFound,
+                    declaration: ptr::null(),
+                }
+            }
+            Err(AliasResolutionError::Cycle) => CMethodAliasTargetResult {
+                status: CMethodAliasResolution::Cycle,
+                declaration: ptr::null(),
+            },
+            Err(err @ (AliasResolutionError::NotAnAlias | AliasResolutionError::TargetNotMethod)) => {
+                panic!("graph inconsistency in method alias resolution: {err:?}")
+            }
+        }
+    })
+}

data/rust/rubydex-sys/src/document_api.rs

@@ -6,6 +6,7 @@ use std::ptr;
 
 use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
 use crate::graph_api::{GraphPointer, with_graph};
+use crate::reference_api::{CMethodReference, MethodReferencesIter};
 use rubydex::model::ids::UriId;
 
 #[derive(Debug)]
@@ -83,3 +84,30 @@ pub unsafe extern "C" fn rdx_document_definitions_iter_new(pointer: GraphPointer
         }
     })
 }
+
+/// Creates a new iterator over method reference IDs for a given document by snapshotting the current set of IDs.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - The returned pointer must be freed with `rdx_method_references_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_document_method_references_iter_new(
+    pointer: GraphPointer,
+    uri_id: u64,
+) -> *mut MethodReferencesIter {
+    with_graph(pointer, |graph| {
+        let uri_id = UriId::new(uri_id);
+        if let Some(doc) = graph.documents().get(&uri_id) {
+            let entries: Vec<_> = doc
+                .method_references()
+                .iter()
+                .map(|ref_id| CMethodReference { id: **ref_id })
+                .collect();
+
+            MethodReferencesIter::new(entries.into_boxed_slice())
+        } else {
+            MethodReferencesIter::new(Vec::<_>::new().into_boxed_slice())
+        }
+    })
+}

data/rust/rubydex-sys/src/graph_api.rs

@@ -7,6 +7,7 @@ use crate::document_api::DocumentsIter;
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::{name_api, utils};
 use libc::{c_char, c_void};
+use rubydex::errors::Errors;
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
@@ -18,7 +19,7 @@ use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver}
 use rubydex::resolution::Resolver;
 use rubydex::{indexing, integrity, listing, query};
 use std::ffi::CString;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::{mem, ptr};
 
 pub type GraphPointer = *mut c_void;
@@ -197,7 +198,13 @@ pub unsafe extern "C" fn rdx_graph_excluded_paths(
         let c_strings: Vec<*const c_char> = excluded
             .iter()
             .filter_map(|path| {
-                CString::new(path.to_string_lossy().as_ref())
+                // Normalize all paths to use forward slashes. Otherwise, you get mixed backslashes and forward slashes
+                // on Windows if a configuration file is using forward slashes. For example:
+                //
+                // C:\project/vendor/bundle
+                let normalized = path.to_string_lossy().replace(std::path::MAIN_SEPARATOR, "/");
+
+                CString::new(normalized)
                     .ok()
                     .map(|c_string| c_string.into_raw().cast_const())
             })
@@ -210,6 +217,69 @@ pub unsafe extern "C" fn rdx_graph_excluded_paths(
     })
 }
 
+/// Sets the workspace path used as the root directory for indexing and relative path resolution. Silently ignores the
+/// call if the given path is not valid UTF-8, leaving the existing workspace path untouched (mirrors
+/// `rdx_graph_set_encoding`). This avoids unwinding across the FFI boundary on malformed input.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - `path` must be a valid, null-terminated string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_set_workspace_path(pointer: GraphPointer, path: *const c_char) {
+    let Ok(path) = (unsafe { utils::convert_char_ptr_to_string(path) }) else {
+        return;
+    };
+
+    with_mut_graph(pointer, |graph| graph.set_workspace_path(PathBuf::from(path)));
+}
+
+/// Returns the workspace path as a C string. Caller must free with `free_c_string`.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_workspace_path(pointer: GraphPointer) -> *const c_char {
+    with_graph(pointer, |graph| {
+        CString::new(graph.workspace_path().to_string_lossy().as_ref())
+            .map_or(ptr::null(), |c_string| c_string.into_raw().cast_const())
+    })
+}
+
+/// Loads configuration into the graph. A null `config_path` attempts to load the default configuration file.
+///
+/// Returns NULL on success. On failure returns an owned, null-terminated error message that the caller must free with
+/// `free_c_string`.
+///
+/// A `config_path` that is not valid UTF-8 is reported as an error message.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - `config_path` must either be NULL or a valid, null-terminated string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_load_config(pointer: GraphPointer, config_path: *const c_char) -> *const c_char {
+    let result = with_mut_graph(pointer, |graph| {
+        if config_path.is_null() {
+            graph.load_config(None)
+        } else {
+            match unsafe { utils::convert_char_ptr_to_string(config_path) } {
+                Ok(config_path) => graph.load_config(Some(Path::new(&config_path))),
+                Err(_) => Err(Errors::ConfigError("config file path is not valid UTF-8".to_string())),
+            }
+        }
+    });
+
+    match result {
+        Ok(()) => ptr::null(),
+        Err(error) => CString::new(error.to_string())
+            .unwrap_or_default()
+            .into_raw()
+            .cast_const(),
+    }
+}
+
 /// Indexes all given file paths in parallel using the provided Graph pointer.
 /// Returns an array of error message strings and writes the count to `out_error_count`.
 /// Returns NULL if there are no errors. Caller must free with `free_c_string_array`.
@@ -232,7 +302,7 @@ pub unsafe extern "C" fn rdx_index_all(
     let file_paths: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(file_paths, count).unwrap() };
 
     with_mut_graph(pointer, |graph| {
-        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, graph.excluded_paths());
+        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, &graph.excluded_paths());
         let indexing_errors = indexing::index_files(graph, file_paths, indexing::IndexerBackend::RubyIndexer);
 
         let all_errors: Vec<String> = listing_errors
@@ -793,9 +863,7 @@ fn run_and_finalize_completion(
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
-/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. When non-null, it
-///   overrides the self-type (e.g., `"Foo::<Foo>"` for completion inside `def Foo.bar`), while
-///   the lexical nesting still comes from `nesting`.
+/// - `self_receiver` is the fully qualified name of the **type of `self`**
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_expression(
     pointer: GraphPointer,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-28 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -52,6 +52,7 @@ files:
 - lib/rubydex/comment.rb
 - lib/rubydex/declaration.rb
 - lib/rubydex/diagnostic.rb
+- lib/rubydex/errors.rb
 - lib/rubydex/failures.rb
 - lib/rubydex/graph.rb
 - lib/rubydex/keyword.rb
@@ -87,8 +88,11 @@ files:
 - rust/rubydex-sys/src/signature_api.rs
 - rust/rubydex-sys/src/utils.rs
 - rust/rubydex/Cargo.toml
+- rust/rubydex/benches/graph_memory.rs
 - rust/rubydex/src/compile_assertions.rs
+- rust/rubydex/src/config.rs
 - rust/rubydex/src/diagnostic.rs
+- rust/rubydex/src/dot.rs
 - rust/rubydex/src/errors.rs
 - rust/rubydex/src/indexing.rs
 - rust/rubydex/src/indexing/local_graph.rs
@@ -133,8 +137,6 @@ files:
 - rust/rubydex/src/test_utils/context.rs
 - rust/rubydex/src/test_utils/graph_test.rs
 - rust/rubydex/src/test_utils/local_graph_test.rs
-- rust/rubydex/src/visualization.rs
-- rust/rubydex/src/visualization/dot.rs
 - rust/rubydex/tests/cli.rs
 - rust/rustfmt.toml
 homepage: https://github.com/Shopify/rubydex