rubydex 0.1.0.beta11 → 0.1.0.beta12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d26e66bf7f1eac1c1bffa154b2a5e2c0621ce59883ae0367202cc82b6f85e64d
-  data.tar.gz: 3ea90f481e9717834e2be5e2a7dc1140810f842e738132496c211b5a19b6837b
+  metadata.gz: 98e6dcc146395bd17fb654d336ad198a58c4726a2345d86c710a644ab85e415d
+  data.tar.gz: c27b9aeda854bac93d5be6c7cde3b77da6c3a2c564baf66c5d5dab4b8075e9e5
 SHA512:
-  metadata.gz: 24f8c2aa31a6d1ad76dd76486d005f3ee1e9143e0624b91db920c33e39da5b1bf248c431d0efc97996019f24f02ed8673912d4731509fcaaa59b1075c84378f9
-  data.tar.gz: 22b831aa47e08e9f3be4390054b645376e3e6d6974eeb2071e7e76499e1f9f056cdf0f0091eb1c28604047c2f0acea68a8e8f15a41ce939fa3acba13956e791f
+  metadata.gz: 4f807b20f75639d56c7df1ba831979d8f5880ac8bfcbabe4f0e23ac2709157f3f49d9feb1e4862645b03b348cdba982e515e9a8da262cab1d4e29e179d937acc
+  data.tar.gz: f4938ecf9d5e6e9fb9cdaa4bdb52318c8988814b7561462a129be1ec5923817a0af1753b09b54fbb5e3f23dbf3f6b9a38e56d788fff420a89197fe5fd31b077d

data/THIRD_PARTY_LICENSES.html

@@ -3336,10 +3336,10 @@ limitations under the License.
                 <ul class="license-used-by">
                     <li><a
                             href=" https://github.com/ruby/rbs.git ">ruby-rbs-sys
-                            0.2.0</a></li>
+                            0.3.0</a></li>
                     <li><a
                             href=" https://github.com/ruby/rbs.git ">ruby-rbs
-                            0.2.0</a></li>
+                            0.3.0</a></li>
                 </ul>
                 <pre class="license-text">Copyright (c) &lt;year&gt; &lt;owner&gt; 
 

data/ext/rubydex/declaration.c

@@ -2,7 +2,6 @@
 #include "definition.h"
 #include "graph.h"
 #include "handle.h"
-#include "reference.h"
 #include "rustbindings.h"
 #include "utils.h"
 
@@ -93,11 +92,10 @@ static VALUE declaration_definitions_yield(VALUE args) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
-    uint64_t id = 0;
-    DefinitionKind kind;
-    while (rdx_definitions_iter_next(iter, &id, &kind)) {
-        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
-        VALUE defn_class = rdxi_definition_class_for_kind(kind);
+    CDefinition defn;
+    while (rdx_definitions_iter_next(iter, &defn)) {
+        VALUE argv[] = {data->graph_obj, ULL2NUM(defn.id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(defn.kind);
         VALUE handle = rb_class_new_instance(2, argv, defn_class);
         rb_yield(handle);
     }
@@ -318,27 +316,30 @@ static VALUE rdxr_declaration_members(VALUE self) {
     return self;
 }
 
-// Size function for the Declaration#references enumerator
-static VALUE declaration_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+// Size function for constant declaration references enumerator
+static VALUE constant_declaration_references_size(VALUE self, VALUE _args, VALUE _eobj) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
     void *graph;
     TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
 
-    struct ReferencesIter *iter = rdx_declaration_references_iter_new(graph, data->id);
-    size_t len = rdx_references_iter_len(iter);
-    rdx_references_iter_free(iter);
+    struct ConstantReferencesIter *iter = rdx_declaration_constant_references_iter_new(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Declaration not found");
+    }
 
+    size_t len = rdx_constant_references_iter_len(iter);
+    rdx_constant_references_iter_free(iter);
     return SIZET2NUM(len);
 }
 
-// Returns an enumerator for all references to this declaration
-//
-// Declaration#references: () -> Enumerator[Reference]
-static VALUE rdxr_declaration_references(VALUE self) {
+// Namespace#references, Constant#references, ConstantAlias#references
+// Returns an enumerator that yields constant references to this declaration
+static VALUE rdxr_constant_declaration_references(VALUE self) {
     if (!rb_block_given_p()) {
-        return rb_enumeratorize_with_size(self, rb_str_new2("references"), 0, NULL, declaration_references_size);
+        return rb_enumeratorize_with_size(self, rb_str_new2("references"), 0, NULL,
+                                          constant_declaration_references_size);
     }
 
     HandleData *data;
@@ -347,13 +348,65 @@ static VALUE rdxr_declaration_references(VALUE self) {
     void *graph;
     TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
 
-    void *iter = rdx_declaration_references_iter_new(graph, data->id);
+    void *iter = rdx_declaration_constant_references_iter_new(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Declaration not found");
+    }
+
     VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
-    rb_ensure(rdxi_references_yield, args, rdxi_references_ensure, args);
+    rb_ensure(rdxi_constant_references_yield, args, rdxi_constant_references_ensure, args);
 
     return self;
 }
 
+// Size function for method declaration references enumerator
+static VALUE method_declaration_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    struct MethodReferencesIter *iter = rdx_declaration_method_references_iter_new(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Declaration not found");
+    }
+
+    size_t len = rdx_method_references_iter_len(iter);
+    rdx_method_references_iter_free(iter);
+    return SIZET2NUM(len);
+}
+
+// Method#references
+// Returns an enumerator that yields method references to this declaration
+static VALUE rdxr_method_declaration_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("references"), 0, NULL,
+                                          method_declaration_references_size);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    void *iter = rdx_declaration_method_references_iter_new(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Declaration not found");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_method_references_yield, args, rdxi_method_references_ensure, args);
+
+    return self;
+}
+
+// Placeholder for variable declarations that don't yet support references
+static VALUE rdxr_variable_declaration_references(VALUE self) {
+    return rb_ary_new();
+}
+
 void rdxi_initialize_declaration(VALUE mRubydex) {
     cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
     cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
@@ -373,10 +426,10 @@ void rdxi_initialize_declaration(VALUE mRubydex) {
     rb_define_method(cDeclaration, "name", rdxr_declaration_name, 0);
     rb_define_method(cDeclaration, "unqualified_name", rdxr_declaration_unqualified_name, 0);
     rb_define_method(cDeclaration, "definitions", rdxr_declaration_definitions, 0);
-    rb_define_method(cDeclaration, "references", rdxr_declaration_references, 0);
     rb_define_method(cDeclaration, "owner", rdxr_declaration_owner, 0);
 
     // Namespace only methods
+    rb_define_method(cNamespace, "references", rdxr_constant_declaration_references, 0);
     rb_define_method(cNamespace, "member", rdxr_declaration_member, 1);
     rb_define_method(cNamespace, "find_member", rdxr_declaration_find_member, -1);
     rb_define_method(cNamespace, "singleton_class", rdxr_declaration_singleton_class, 0);
@@ -384,5 +437,17 @@ void rdxi_initialize_declaration(VALUE mRubydex) {
     rb_define_method(cNamespace, "descendants", rdxr_declaration_descendants, 0);
     rb_define_method(cNamespace, "members", rdxr_declaration_members, 0);
 
+    // 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);
+
+    // Method has method references
+    rb_define_method(cMethod, "references", rdxr_method_declaration_references, 0);
+
+    // Variable declarations don't yet support references
+    rb_define_method(cGlobalVariable, "references", rdxr_variable_declaration_references, 0);
+    rb_define_method(cInstanceVariable, "references", rdxr_variable_declaration_references, 0);
+    rb_define_method(cClassVariable, "references", rdxr_variable_declaration_references, 0);
+
     rb_funcall(rb_singleton_class(cDeclaration), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 }

data/ext/rubydex/definition.c

@@ -2,10 +2,14 @@
 #include "graph.h"
 #include "handle.h"
 #include "location.h"
+#include "reference.h"
 #include "ruby/internal/scan_args.h"
 #include "rustbindings.h"
 
 static VALUE mRubydex;
+static VALUE cInclude;
+static VALUE cPrepend;
+static VALUE cExtend;
 VALUE cComment;
 VALUE cDefinition;
 VALUE cClassDefinition;
@@ -14,6 +18,7 @@ VALUE cModuleDefinition;
 VALUE cConstantDefinition;
 VALUE cConstantAliasDefinition;
 VALUE cConstantVisibilityDefinition;
+VALUE cMethodVisibilityDefinition;
 VALUE cMethodDefinition;
 VALUE cAttrAccessorDefinition;
 VALUE cAttrReaderDefinition;
@@ -39,6 +44,8 @@ VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
         return cConstantAliasDefinition;
     case DefinitionKind_ConstantVisibility:
         return cConstantVisibilityDefinition;
+    case DefinitionKind_MethodVisibility:
+        return cMethodVisibilityDefinition;
     case DefinitionKind_Method:
         return cMethodDefinition;
     case DefinitionKind_AttrAccessor:
@@ -164,9 +171,81 @@ static VALUE rdxr_definition_name_location(VALUE self) {
     return location;
 }
 
+static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
+    VALUE ref_class = (cref->declaration_id == 0)
+        ? cUnresolvedConstantReference
+        : cResolvedConstantReference;
+
+    VALUE argv[] = {graph_obj, ULL2NUM(cref->id)};
+    return rb_class_new_instance(2, argv, ref_class);
+}
+
+// ClassDefinition#superclass -> ConstantReference?
+static VALUE rdxr_class_definition_superclass(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 CConstantReference *ref = rdx_class_definition_superclass(graph, data->id);
+    if (ref == NULL) {
+        return Qnil;
+    }
+
+    VALUE result = rdxi_build_constant_reference(data->graph_obj, ref);
+    free_c_constant_reference(ref);
+    return result;
+}
+
+static VALUE rdxi_mixin_class_for_kind(MixinKind kind) {
+    switch (kind) {
+    case MixinKind_Include:
+        return cInclude;
+    case MixinKind_Prepend:
+        return cPrepend;
+    case MixinKind_Extend:
+        return cExtend;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown MixinKind: %d", kind);
+    }
+}
+
+// Definition#mixins -> [Rubydex::Mixin]
+static VALUE rdxr_definition_mixins(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    MixinsIter *iter = rdx_definition_mixins(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Tried to get mixins for a definition that isn't a namespace");
+    }
+
+    size_t len = rdx_mixins_iter_len(iter);
+    VALUE ary = rb_ary_new_capa((long)len);
+
+    CMixin entry;
+    while (rdx_mixins_iter_next(iter, &entry)) {
+        VALUE constant_ref = rdxi_build_constant_reference(data->graph_obj, &entry.constant_reference);
+        VALUE mixin_class = rdxi_mixin_class_for_kind(entry.kind);
+        VALUE mixin = rb_class_new_instance(1, &constant_ref, mixin_class);
+        rb_ary_push(ary, mixin);
+    }
+
+    rdx_mixins_iter_free(iter);
+    return ary;
+}
+
 void rdxi_initialize_definition(VALUE mod) {
     mRubydex = mod;
 
+    cInclude = rb_const_get(mRubydex, rb_intern("Include"));
+    cPrepend = rb_const_get(mRubydex, rb_intern("Prepend"));
+    cExtend = rb_const_get(mRubydex, rb_intern("Extend"));
+
     cComment = rb_define_class_under(mRubydex, "Comment", rb_cObject);
 
     cDefinition = rb_define_class_under(mRubydex, "Definition", rb_cObject);
@@ -180,11 +259,19 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
+    rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
+    rb_define_method(cClassDefinition, "mixins", rdxr_definition_mixins, 0);
+
     cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
+    rb_define_method(cSingletonClassDefinition, "mixins", rdxr_definition_mixins, 0);
+
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    rb_define_method(cModuleDefinition, "mixins", rdxr_definition_mixins, 0);
+
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
     cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
+    cMethodVisibilityDefinition = rb_define_class_under(mRubydex, "MethodVisibilityDefinition", cDefinition);
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
     cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
     cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);

data/ext/rubydex/document.c

@@ -33,11 +33,10 @@ static VALUE document_definitions_yield(VALUE args) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
-    uint64_t id = 0;
-    DefinitionKind kind;
-    while (rdx_definitions_iter_next(iter, &id, &kind)) {
-        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
-        VALUE defn_class = rdxi_definition_class_for_kind(kind);
+    CDefinition defn;
+    while (rdx_definitions_iter_next(iter, &defn)) {
+        VALUE argv[] = {data->graph_obj, ULL2NUM(defn.id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(defn.kind);
         VALUE handle = rb_class_new_instance(2, argv, defn_class);
         rb_yield(handle);
     }

data/ext/rubydex/extconf.rb

@@ -8,7 +8,18 @@ unless system("cargo", "--version", out: File::NULL, err: File::NULL)
 end
 
 gem_dir = Pathname.new("../..").expand_path(__dir__)
-release = ENV["RELEASE"] || !gem_dir.join(".git").exist?
+
+# Use release mode for the compilation if:
+# - The RELEASE environment variable is set
+# - We're not working on Rubydex (BUNDLE_GEMFILE doesn't point to Rubydex's own Gemfile)
+#
+# We only need debug builds when working on Rubydex itself and on CI. This approach also lets people install Rubydex
+# from the git source and get a release mode build
+
+bundle_gemfile = ENV["BUNDLE_GEMFILE"]
+developing_rubydex = bundle_gemfile && Pathname.new(bundle_gemfile).expand_path.dirname == gem_dir
+release = ENV["RELEASE"] || !developing_rubydex
+
 root_dir = gem_dir.join("rust")
 target_dir = root_dir.join("target")
 target_dir = target_dir.join("x86_64-pc-windows-gnu") if Gem.win_platform?

data/ext/rubydex/graph.c

@@ -10,6 +10,8 @@
 
 static VALUE cGraph;
 static VALUE mRubydex;
+static VALUE cKeyword;
+static VALUE cKeywordParameter;
 
 // Free function for the custom Graph allocator. We always have to call into Rust to free data allocated by it
 static void graph_free(void *ptr) {
@@ -246,9 +248,9 @@ static VALUE graph_constant_references_size(VALUE self, VALUE _args, VALUE _eobj
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    ReferencesIter *iter = rdx_graph_constant_references_iter_new(graph);
-    size_t len = rdx_references_iter_len(iter);
-    rdx_references_iter_free(iter);
+    struct ConstantReferencesIter *iter = rdx_graph_constant_references_iter_new(graph);
+    size_t len = rdx_constant_references_iter_len(iter);
+    rdx_constant_references_iter_free(iter);
 
     return SIZET2NUM(len);
 }
@@ -266,7 +268,7 @@ static VALUE rdxr_graph_constant_references(VALUE self) {
 
     void *iter = rdx_graph_constant_references_iter_new(graph);
     VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
-    rb_ensure(rdxi_references_yield, args, rdxi_references_ensure, args);
+    rb_ensure(rdxi_constant_references_yield, args, rdxi_constant_references_ensure, args);
 
     return self;
 }
@@ -276,9 +278,9 @@ static VALUE graph_method_references_size(VALUE self, VALUE _args, VALUE _eobj)
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    ReferencesIter *iter = rdx_graph_method_references_iter_new(graph);
-    size_t len = rdx_references_iter_len(iter);
-    rdx_references_iter_free(iter);
+    struct MethodReferencesIter *iter = rdx_graph_method_references_iter_new(graph);
+    size_t len = rdx_method_references_iter_len(iter);
+    rdx_method_references_iter_free(iter);
 
     return SIZET2NUM(len);
 }
@@ -296,7 +298,7 @@ static VALUE rdxr_graph_method_references(VALUE self) {
 
     void *iter = rdx_graph_method_references_iter_new(graph);
     VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
-    rb_ensure(rdxi_references_yield, args, rdxi_references_ensure, args);
+    rb_ensure(rdxi_method_references_yield, args, rdxi_method_references_ensure, args);
 
     return self;
 }
@@ -488,9 +490,170 @@ static VALUE rdxr_graph_diagnostics(VALUE self) {
     return diagnostics;
 }
 
+// Helper: convert a CompletionResult into a Ruby array, raising ArgumentError on error.
+static VALUE completion_result_to_ruby_array(struct CompletionResult result, VALUE graph_obj) {
+    if (result.error != NULL) {
+        VALUE msg = rb_utf8_str_new_cstr(result.error);
+        free_c_string(result.error);
+        rb_raise(rb_eArgError, "%s", StringValueCStr(msg));
+    }
+
+    CompletionCandidateArray *array = result.candidates;
+    if (array == NULL) {
+        return rb_ary_new();
+    }
+
+    if (array->len == 0) {
+        rdx_completion_candidates_free(array);
+        return rb_ary_new();
+    }
+
+    VALUE ruby_array = rb_ary_new_capa((long)array->len);
+
+    for (size_t i = 0; i < array->len; i++) {
+        CCompletionCandidate item = array->items[i];
+        VALUE obj;
+
+        switch (item.kind) {
+        case CCompletionCandidateKind_Declaration: {
+            VALUE decl_class = rdxi_declaration_class_for_kind(item.declaration->kind);
+            VALUE argv[] = {graph_obj, ULL2NUM(item.declaration->id)};
+            obj = rb_class_new_instance(2, argv, decl_class);
+            break;
+        }
+        case CCompletionCandidateKind_Keyword: {
+            VALUE argv[2] = {
+                rb_utf8_str_new_cstr(item.name),
+                rb_utf8_str_new_cstr(item.documentation),
+            };
+            obj = rb_class_new_instance(2, argv, cKeyword);
+            break;
+        }
+        case CCompletionCandidateKind_KeywordParameter: {
+            VALUE argv[1] = { rb_utf8_str_new_cstr(item.name) };
+            obj = rb_class_new_instance(1, argv, cKeywordParameter);
+            break;
+        }
+        default:
+            rdx_completion_candidates_free(array);
+            rb_raise(rb_eRuntimeError, "Unknown CCompletionCandidateKind: %d", item.kind);
+        }
+
+        rb_ary_push(ruby_array, obj);
+    }
+
+    rdx_completion_candidates_free(array);
+    return ruby_array;
+}
+
+// Graph#complete_expression: (Array[String] nesting) -> Array[Declaration | Keyword]
+// Returns completion candidates for an expression context.
+// The nesting array represents the lexical scope stack
+static VALUE rdxr_graph_complete_expression(VALUE self, VALUE nesting) {
+    rdxi_check_array_of_strings(nesting);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    size_t nesting_count = RARRAY_LEN(nesting);
+    char **converted_nesting = rdxi_str_array_to_char(nesting, nesting_count);
+
+    struct CompletionResult result =
+        rdx_graph_complete_expression(graph, (const char *const *)converted_nesting, nesting_count);
+
+    rdxi_free_str_array(converted_nesting, nesting_count);
+    return completion_result_to_ruby_array(result, self);
+}
+
+// Graph#complete_namespace_access: (String name) -> Array[Declaration]
+// Returns completion candidates after a namespace access operator (e.g., `Foo::`).
+static VALUE rdxr_graph_complete_namespace_access(VALUE self, VALUE name) {
+    Check_Type(name, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    struct CompletionResult result = rdx_graph_complete_namespace_access(graph, StringValueCStr(name));
+    return completion_result_to_ruby_array(result, self);
+}
+
+// Graph#complete_method_call: (String name) -> Array[Declaration]
+// Returns completion candidates after a method call operator (e.g., `foo.`).
+static VALUE rdxr_graph_complete_method_call(VALUE self, VALUE name) {
+    Check_Type(name, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    struct CompletionResult result = rdx_graph_complete_method_call(graph, StringValueCStr(name));
+    return completion_result_to_ruby_array(result, self);
+}
+
+// Graph#complete_method_argument: (String name, Array[String] nesting) -> Array[Declaration | Keyword | KeywordParameter]
+// Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`).
+static VALUE rdxr_graph_complete_method_argument(VALUE self, VALUE name, VALUE nesting) {
+    Check_Type(name, T_STRING);
+    rdxi_check_array_of_strings(nesting);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    size_t nesting_count = RARRAY_LEN(nesting);
+    char **converted_nesting = rdxi_str_array_to_char(nesting, nesting_count);
+
+    struct CompletionResult result = rdx_graph_complete_method_argument(
+        graph, StringValueCStr(name), (const char *const *)converted_nesting, nesting_count);
+
+    rdxi_free_str_array(converted_nesting, nesting_count);
+    return completion_result_to_ruby_array(result, self);
+}
+
+// Graph#exclude_paths: (Array[String] paths) -> void
+// Excludes the given paths from file discovery during indexing.
+static VALUE rdxr_graph_exclude_paths(VALUE self, VALUE paths) {
+    Check_Type(paths, T_ARRAY);
+    rdxi_check_array_of_strings(paths);
+
+    size_t length = RARRAY_LEN(paths);
+    char **converted_paths = rdxi_str_array_to_char(paths, length);
+
+    void *graph;
+    TypedData_Get_Struct(self, void*, &graph_type, graph);
+
+    rdx_graph_exclude_paths(graph, (const char **)converted_paths, length);
+    rdxi_free_str_array(converted_paths, length);
+
+    return Qnil;
+}
+
+// Graph#excluded_paths: () -> Array[String]
+// Returns the list of paths currently excluded from file discovery.
+static VALUE rdxr_graph_excluded_paths(VALUE self) {
+    void *graph;
+    TypedData_Get_Struct(self, void*, &graph_type, graph);
+
+    size_t out_count = 0;
+    const char *const *results = rdx_graph_excluded_paths(graph, &out_count);
+
+    if (results == NULL) {
+        return rb_ary_new();
+    }
+
+    VALUE array = rb_ary_new_capa((long)out_count);
+    for (size_t i = 0; i < out_count; i++) {
+        rb_ary_push(array, rb_utf8_str_new_cstr(results[i]));
+    }
+
+    free_c_string_array(results, out_count);
+    return array;
+}
+
 void rdxi_initialize_graph(VALUE moduleRubydex) {
     mRubydex = moduleRubydex;
     cGraph = rb_define_class_under(mRubydex, "Graph", rb_cObject);
+    cKeyword = rb_define_class_under(mRubydex, "Keyword", rb_cObject);
+    cKeywordParameter = rb_define_class_under(mRubydex, "KeywordParameter", rb_cObject);
+
     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);
@@ -509,4 +672,10 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "encoding=", rdxr_graph_set_encoding, 1);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);
+    rb_define_method(cGraph, "complete_expression", rdxr_graph_complete_expression, 1);
+    rb_define_method(cGraph, "complete_namespace_access", rdxr_graph_complete_namespace_access, 1);
+    rb_define_method(cGraph, "complete_method_call", rdxr_graph_complete_method_call, 1);
+    rb_define_method(cGraph, "complete_method_argument", rdxr_graph_complete_method_argument, 2);
+    rb_define_method(cGraph, "exclude_paths", rdxr_graph_exclude_paths, 1);
+    rb_define_method(cGraph, "excluded_paths", rdxr_graph_excluded_paths, 0);
 }

data/ext/rubydex/reference.c

@@ -1,4 +1,5 @@
 #include "reference.h"
+#include "declaration.h"
 #include "graph.h"
 #include "handle.h"
 #include "location.h"
@@ -6,6 +7,8 @@
 
 VALUE cReference;
 VALUE cConstantReference;
+VALUE cUnresolvedConstantReference;
+VALUE cResolvedConstantReference;
 VALUE cMethodReference;
 
 // ConstantReference#name -> String
@@ -72,16 +75,24 @@ static VALUE rdxr_method_reference_location(VALUE self) {
     return location;
 }
 
-// Keep this in sync with unresolved_reference_api.rs
-VALUE rdxi_reference_class_for_kind(ReferenceKind kind) {
-    switch (kind) {
-    case ReferenceKind_Constant:
-        return cConstantReference;
-    case ReferenceKind_Method:
-        return cMethodReference;
-    default:
-        rb_raise(rb_eRuntimeError, "Unknown UnresolvedReferenceKind: %d", kind);
+// ResolvedConstantReference#declaration -> Declaration
+static VALUE rdxr_resolved_constant_reference_declaration(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_resolved_constant_reference_declaration(graph, data->id);
+    if (decl == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid declaration for a resolved constant reference");
     }
+
+    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_reference(VALUE mRubydex) {
@@ -93,8 +104,16 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     cConstantReference = rb_define_class_under(mRubydex, "ConstantReference", cReference);
     rb_define_alloc_func(cConstantReference, rdxr_handle_alloc);
     rb_define_method(cConstantReference, "initialize", rdxr_handle_initialize, 2);
-    rb_define_method(cConstantReference, "name", rdxr_constant_reference_name, 0);
     rb_define_method(cConstantReference, "location", rdxr_constant_reference_location, 0);
+    rb_funcall(rb_singleton_class(cConstantReference), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+
+    cUnresolvedConstantReference = rb_define_class_under(mRubydex, "UnresolvedConstantReference", cConstantReference);
+    rb_define_alloc_func(cUnresolvedConstantReference, rdxr_handle_alloc);
+    rb_define_method(cUnresolvedConstantReference, "name", rdxr_constant_reference_name, 0);
+
+    cResolvedConstantReference = rb_define_class_under(mRubydex, "ResolvedConstantReference", cConstantReference);
+    rb_define_alloc_func(cResolvedConstantReference, rdxr_handle_alloc);
+    rb_define_method(cResolvedConstantReference, "declaration", rdxr_resolved_constant_reference_declaration, 0);
 
     cMethodReference = rb_define_class_under(mRubydex, "MethodReference", cReference);
     rb_define_alloc_func(cMethodReference, rdxr_handle_alloc);

data/ext/rubydex/reference.h

@@ -6,11 +6,10 @@
 
 extern VALUE cReference;
 extern VALUE cConstantReference;
+extern VALUE cUnresolvedConstantReference;
+extern VALUE cResolvedConstantReference;
 extern VALUE cMethodReference;
 
 void rdxi_initialize_reference(VALUE mRubydex);
 
-// Returns the Ruby class for a given UnresolvedReferenceKind without calling back into Rust
-VALUE rdxi_reference_class_for_kind(ReferenceKind kind);
-
 #endif // RUBYDEX_REFERENCE_H