rubydex 0.2.5 → 0.2.6

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

@@ -793,9 +793,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.6
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-28 00:00:00.000000000 Z
+date: 2026-06-25 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
@@ -89,6 +90,7 @@ files:
 - rust/rubydex/Cargo.toml
 - rust/rubydex/src/compile_assertions.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 +135,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

data/rust/rubydex/src/visualization/dot.rs

@@ -1,192 +0,0 @@
-//! DOT format generator for Graphviz visualization of the graph structure.
-
-use std::fmt::Write;
-
-use crate::model::graph::Graph;
-
-const NAME_NODE_SHAPE: &str = "hexagon";
-const DEFINITION_NODE_SHAPE: &str = "ellipse";
-const URI_NODE_SHAPE: &str = "box";
-
-/// Escapes a string for use in DOT format labels and identifiers.
-fn escape_dot_string(s: &str) -> String {
-    if !s.contains('"') {
-        return s.to_string();
-    }
-
-    let mut result = String::with_capacity(s.len());
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            _ => result.push(c),
-        }
-    }
-    result
-}
-
-#[must_use]
-pub fn generate(graph: &Graph) -> String {
-    let mut output = String::new();
-    output.push_str("digraph {\n");
-    output.push_str("    rankdir=TB;\n\n");
-
-    write_declaration_nodes(&mut output, graph);
-    write_definition_nodes(&mut output, graph);
-    write_document_nodes(&mut output, graph);
-
-    output.push_str("}\n");
-    output
-}
-
-fn write_declaration_nodes(output: &mut String, graph: &Graph) {
-    let mut declarations: Vec<_> = graph.declarations().values().collect();
-    declarations.sort_by(|a, b| a.name().cmp(b.name()));
-
-    for declaration in declarations {
-        let name = declaration.name();
-        let escaped_name = escape_dot_string(name);
-        let node_id = format!("Name:{name}");
-        let _ = writeln!(
-            output,
-            "    \"{node_id}\" [label=\"{escaped_name}\",shape={NAME_NODE_SHAPE}];"
-        );
-
-        for def_id in declaration.definitions() {
-            let _ = writeln!(output, "    \"{node_id}\" -> \"def_{def_id}\" [dir=both];");
-        }
-    }
-
-    output.push('\n');
-}
-
-fn write_definition_nodes(output: &mut String, graph: &Graph) {
-    let mut definitions: Vec<_> = graph
-        .definitions()
-        .iter()
-        .filter_map(|(def_id, definition)| {
-            graph
-                .declarations()
-                .get(graph.definition_to_declaration_id(definition).unwrap())
-                .map(|declaration| {
-                    let def_type = definition.kind();
-                    let escaped_name = escape_dot_string(declaration.name());
-                    let label = format!("{def_type}({escaped_name})");
-                    let line = format!("    \"def_{def_id}\" [label=\"{label}\",shape={DEFINITION_NODE_SHAPE}];\n");
-                    (label, line)
-                })
-        })
-        .collect();
-
-    definitions.sort_by(|a, b| a.0.cmp(&b.0));
-
-    for (_, line) in definitions {
-        output.push_str(&line);
-    }
-    output.push('\n');
-}
-
-fn write_document_nodes(output: &mut String, graph: &Graph) {
-    let mut documents: Vec<_> = graph.documents().values().collect();
-    documents.sort_by(|a, b| a.uri().cmp(b.uri()));
-
-    for document in documents {
-        let uri = document.uri();
-        let label = uri.rsplit('/').next().unwrap_or(uri);
-        let escaped_uri = escape_dot_string(uri);
-        let escaped_label = escape_dot_string(label);
-        let _ = writeln!(
-            output,
-            "    \"{escaped_uri}\" [label=\"{escaped_label}\",shape={URI_NODE_SHAPE}];"
-        );
-
-        for def_id in document.definitions() {
-            let _ = writeln!(output, "    \"def_{def_id}\" -> \"{escaped_uri}\";");
-        }
-    }
-    output.push('\n');
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{model::ids::DeclarationId, test_utils::GraphTest};
-
-    fn create_test_graph() -> GraphTest {
-        let mut graph_test = GraphTest::new();
-        graph_test.index_uri(
-            "file:///test.rb",
-            "
-                class TestClass
-                end
-
-                module TestModule
-                end
-            ",
-        );
-        graph_test.resolve();
-        graph_test
-    }
-
-    /// Finds the first definition ID for the declaration with the given name.
-    fn def_id_for(graph: &Graph, name: &str) -> String {
-        let decl = graph.declarations().get(&DeclarationId::from(name)).unwrap();
-        decl.definitions().first().unwrap().to_string()
-    }
-
-    #[test]
-    fn test_dot_generation() {
-        let context = create_test_graph();
-        let dot_output = generate(context.graph());
-
-        let basic_object_def = def_id_for(context.graph(), "BasicObject");
-        let class_def = def_id_for(context.graph(), "Class");
-        let kernel_def = def_id_for(context.graph(), "Kernel");
-        let module_def = def_id_for(context.graph(), "Module");
-        let object_def = def_id_for(context.graph(), "Object");
-        let test_class_def = def_id_for(context.graph(), "TestClass");
-        let test_module_def = def_id_for(context.graph(), "TestModule");
-
-        let expected = format!(
-            r#"digraph {{
-    rankdir=TB;
-
-    "Name:BasicObject" [label="BasicObject",shape=hexagon];
-    "Name:BasicObject" -> "def_{basic_object_def}" [dir=both];
-    "Name:Class" [label="Class",shape=hexagon];
-    "Name:Class" -> "def_{class_def}" [dir=both];
-    "Name:Kernel" [label="Kernel",shape=hexagon];
-    "Name:Kernel" -> "def_{kernel_def}" [dir=both];
-    "Name:Module" [label="Module",shape=hexagon];
-    "Name:Module" -> "def_{module_def}" [dir=both];
-    "Name:Object" [label="Object",shape=hexagon];
-    "Name:Object" -> "def_{object_def}" [dir=both];
-    "Name:TestClass" [label="TestClass",shape=hexagon];
-    "Name:TestClass" -> "def_{test_class_def}" [dir=both];
-    "Name:TestModule" [label="TestModule",shape=hexagon];
-    "Name:TestModule" -> "def_{test_module_def}" [dir=both];
-
-    "def_{basic_object_def}" [label="Class(BasicObject)",shape=ellipse];
-    "def_{class_def}" [label="Class(Class)",shape=ellipse];
-    "def_{module_def}" [label="Class(Module)",shape=ellipse];
-    "def_{object_def}" [label="Class(Object)",shape=ellipse];
-    "def_{test_class_def}" [label="Class(TestClass)",shape=ellipse];
-    "def_{kernel_def}" [label="Module(Kernel)",shape=ellipse];
-    "def_{test_module_def}" [label="Module(TestModule)",shape=ellipse];
-
-    "file:///test.rb" [label="test.rb",shape=box];
-    "def_{test_class_def}" -> "file:///test.rb";
-    "def_{test_module_def}" -> "file:///test.rb";
-    "rubydex:built-in" [label="rubydex:built-in",shape=box];
-    "def_{basic_object_def}" -> "rubydex:built-in";
-    "def_{kernel_def}" -> "rubydex:built-in";
-    "def_{object_def}" -> "rubydex:built-in";
-    "def_{module_def}" -> "rubydex:built-in";
-    "def_{class_def}" -> "rubydex:built-in";
-
-}}
-"#
-        );
-
-        assert_eq!(dot_output, expected);
-    }
-}

data/rust/rubydex/src/visualization.rs

@@ -1,6 +0,0 @@
-//! Graph visualization module for the Index structure.
-//!
-//! This module provides functionality to generate visual representations of the Index's
-//! internal graph structure, showing the relationships between Names, Definitions, and URIs.
-
-pub mod dot;