rubydex 0.1.0.beta2-x86_64-linux → 0.1.0.beta3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4cd7117d9875054427596fc86ec03777c49f83def03b61e88854054ed3ba29e
-  data.tar.gz: 784d1100f887338f37156b1154abe838809620fee042a9ee1e6ddb7bce1343e6
+  metadata.gz: 2de40c7335743a85b7d61d9a513d40b29fcecf62e19cfff8ef2637cd4297b6a8
+  data.tar.gz: 99bed4d413ab7e1bd97f76965906037d1da29f12af8dba7f19f48d5665c73bc5
 SHA512:
-  metadata.gz: '084c9c76384daa40ba132d79fd4e4ef8971e4e7f0d1dd33af187ae004507c8b5135b2d241e222acbd47adfc92c043b94924b45e1f7e6f2cda51d783f310c63a4'
-  data.tar.gz: dd14d62e46de868f0622c72d379816ef913f0696454507458bb7d7598a6d3f334502a0b4470b5d6775861e208e46b069fcc78efcc6ef1b06b553696dffc7f18b
+  metadata.gz: 29ef5b84c94af6eb1608d42acbc7a0c5c115fef6317645b369fca27c1c1714c64a21dba7a1b10f490939fbf547583fbed20db30d26e9ad4f42b9c8079c8b7e6c
+  data.tar.gz: e4d9dce9acf24ef5c704dab14d89a82143c39e259e8923fc71830abe600b54240094a8e287aa647b62e419fac42db6e1c3f4b59d20b29498d1b5872865083dd5

data/THIRD_PARTY_LICENSES.html

@@ -53,6 +53,7 @@
             <li><a href="#Apache-2.0">Apache License 2.0</a> (106)</li>
             <li><a href="#Unicode-3.0">Unicode License v3</a> (19)</li>
             <li><a href="#MIT">MIT License</a> (15)</li>
+            <li><a href="#BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</a> (2)</li>
             <li><a href="#BSD-3-Clause">BSD 3-Clause &quot;New&quot; or &quot;Revised&quot; License</a> (1)</li>
             <li><a href="#BSL-1.0">Boost Software License 1.0</a> (1)</li>
             <li><a href="#ISC">ISC License</a> (1)</li>
@@ -2332,6 +2333,28 @@ distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+</pre>
+            </li>
+            <li class="license">
+                <h3 id="BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</h3>
+                <h4>Used by:</h4>
+                <ul class="license-used-by">
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs-sys
+                            0.1.1</a></li>
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs
+                            0.1.1</a></li>
+                </ul>
+                <pre class="license-text">Copyright (c) &lt;year&gt; &lt;owner&gt; 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 </pre>
             </li>
             <li class="license">
@@ -2539,10 +2562,10 @@ THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRES
                 <ul class="license-used-by">
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism-sys
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                 </ul>
                 <pre class="license-text">Copyright 2022-present, Shopify Inc.
 

data/ext/rubydex/declaration.c

@@ -3,8 +3,45 @@
 #include "graph.h"
 #include "handle.h"
 #include "rustbindings.h"
+#include "utils.h"
 
 VALUE cDeclaration;
+VALUE cNamespace;
+VALUE cClass;
+VALUE cModule;
+VALUE cSingletonClass;
+VALUE cConstant;
+VALUE cConstantAlias;
+VALUE cMethod;
+VALUE cGlobalVariable;
+VALUE cInstanceVariable;
+VALUE cClassVariable;
+
+// Keep this in sync with declaration_api.rs
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind) {
+    switch (kind) {
+    case CDeclarationKind_Class:
+        return cClass;
+    case CDeclarationKind_Module:
+        return cModule;
+    case CDeclarationKind_SingletonClass:
+        return cSingletonClass;
+    case CDeclarationKind_Constant:
+        return cConstant;
+    case CDeclarationKind_ConstantAlias:
+        return cConstantAlias;
+    case CDeclarationKind_Method:
+        return cMethod;
+    case CDeclarationKind_GlobalVariable:
+        return cGlobalVariable;
+    case CDeclarationKind_InstanceVariable:
+        return cInstanceVariable;
+    case CDeclarationKind_ClassVariable:
+        return cClassVariable;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CDeclarationKind: %d", kind);
+    }
+}
 
 // Declaration#name -> String
 static VALUE rdxr_declaration_name(VALUE self) {
@@ -52,10 +89,10 @@ static VALUE declaration_definitions_yield(VALUE args) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
-    int64_t id = 0;
+    uint64_t id = 0;
     DefinitionKind kind;
     while (rdx_definitions_iter_next(iter, &id, &kind)) {
-        VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
         VALUE defn_class = rdxi_definition_class_for_kind(kind);
         VALUE handle = rb_class_new_instance(2, argv, defn_class);
         rb_yield(handle);
@@ -120,27 +157,129 @@ static VALUE rdxr_declaration_member(VALUE self, VALUE name) {
         rb_raise(rb_eTypeError, "expected String");
     }
 
-    const int64_t *id_ptr = rdx_declaration_member(graph, data->id, StringValueCStr(name));
-    if (id_ptr == NULL) {
+    const CDeclaration *decl = rdx_declaration_member(graph, data->id, StringValueCStr(name));
+    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);
+}
+
+// Declaration#singleton_class -> SingletonClass
+static VALUE rdxr_declaration_singleton_class(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_declaration_singleton_class(graph, data->id);
+
+    if (decl == NULL) {
         return Qnil;
     }
 
-    int64_t id = *id_ptr;
-    free_i64(id_ptr);
-    VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+    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);
+}
+
+// Declaration#owner -> Declaration
+static VALUE rdxr_declaration_owner(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_declaration_owner(graph, data->id);
+
+    if (decl == NULL) {
+        rb_raise(rb_eRuntimeError, "owner can never be nil for any declarations");
+    }
+
+    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);
+}
+
+// Declaration#ancestors: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_ancestors(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("ancestors"), 0, NULL);
+    }
+
+    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_ancestors(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
+
+    return self;
+}
+
+// Declaration#descendants: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_descendants(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("descendants"), 0, NULL);
+    }
+
+    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_descendants(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
 
-    return rb_class_new_instance(2, argv, cDeclaration);
+    return self;
 }
 
 void rdxi_initialize_declaration(VALUE mRubydex) {
     cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
+    cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
+    cClass = rb_define_class_under(mRubydex, "Class", cNamespace);
+    cModule = rb_define_class_under(mRubydex, "Module", cNamespace);
+    cSingletonClass = rb_define_class_under(mRubydex, "SingletonClass", cNamespace);
+    cConstant = rb_define_class_under(mRubydex, "Constant", cDeclaration);
+    cConstantAlias = rb_define_class_under(mRubydex, "ConstantAlias", cDeclaration);
+    cMethod = rb_define_class_under(mRubydex, "Method", cDeclaration);
+    cGlobalVariable = rb_define_class_under(mRubydex, "GlobalVariable", cDeclaration);
+    cInstanceVariable = rb_define_class_under(mRubydex, "InstanceVariable", cDeclaration);
+    cClassVariable = rb_define_class_under(mRubydex, "ClassVariable", cDeclaration);
 
     rb_define_alloc_func(cDeclaration, rdxr_handle_alloc);
     rb_define_method(cDeclaration, "initialize", rdxr_handle_initialize, 2);
     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, "member", rdxr_declaration_member, 1);
+    rb_define_method(cDeclaration, "owner", rdxr_declaration_owner, 0);
+
+    // Namespace only methods
+    rb_define_method(cNamespace, "member", rdxr_declaration_member, 1);
+    rb_define_method(cNamespace, "singleton_class", rdxr_declaration_singleton_class, 0);
+    rb_define_method(cNamespace, "ancestors", rdxr_declaration_ancestors, 0);
+    rb_define_method(cNamespace, "descendants", rdxr_declaration_descendants, 0);
 
     rb_funcall(rb_singleton_class(cDeclaration), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 }

data/ext/rubydex/declaration.h

@@ -2,9 +2,21 @@
 #define RUBYDEX_DECLARATION_H
 
 #include "ruby.h"
+#include "rustbindings.h"
 
 extern VALUE cDeclaration;
+extern VALUE cNamespace;
+extern VALUE cClass;
+extern VALUE cModule;
+extern VALUE cSingletonClass;
+extern VALUE cConstant;
+extern VALUE cConstantAlias;
+extern VALUE cMethod;
+extern VALUE cGlobalVariable;
+extern VALUE cInstanceVariable;
+extern VALUE cClassVariable;
 
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind);
 void rdxi_initialize_declaration(VALUE mRubydex);
 
 #endif // RUBYDEX_DECLARATION_H

data/ext/rubydex/definition.c

@@ -177,58 +177,17 @@ 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_alloc_func(cClassDefinition, rdxr_handle_alloc);
-    rb_define_method(cClassDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
-    rb_define_alloc_func(cSingletonClassDefinition, rdxr_handle_alloc);
-    rb_define_method(cSingletonClassDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
-    rb_define_alloc_func(cModuleDefinition, rdxr_handle_alloc);
-    rb_define_method(cModuleDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
-    rb_define_alloc_func(cConstantDefinition, rdxr_handle_alloc);
-    rb_define_method(cConstantDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
-    rb_define_alloc_func(cConstantAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cConstantAliasDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
-    rb_define_alloc_func(cMethodDefinition, rdxr_handle_alloc);
-    rb_define_method(cMethodDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
-    rb_define_alloc_func(cAttrAccessorDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrAccessorDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);
-    rb_define_alloc_func(cAttrReaderDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrReaderDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrWriterDefinition = rb_define_class_under(mRubydex, "AttrWriterDefinition", cDefinition);
-    rb_define_alloc_func(cAttrWriterDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrWriterDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cGlobalVariableDefinition = rb_define_class_under(mRubydex, "GlobalVariableDefinition", cDefinition);
-    rb_define_alloc_func(cGlobalVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cGlobalVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cInstanceVariableDefinition = rb_define_class_under(mRubydex, "InstanceVariableDefinition", cDefinition);
-    rb_define_alloc_func(cInstanceVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cInstanceVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
-    rb_define_alloc_func(cClassVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cClassVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
-    rb_define_alloc_func(cMethodAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cMethodAliasDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
-    rb_define_alloc_func(cGlobalVariableAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cGlobalVariableAliasDefinition, "initialize", rdxr_handle_initialize, 2);
 }

data/ext/rubydex/document.c

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

data/ext/rubydex/extconf.rb

@@ -56,7 +56,7 @@ end
 create_makefile("rubydex/rubydex")
 
 cargo_command = if ENV["SANITIZER"]
-  ENV["RUSTFLAGS"] = "-Zsanitizer=#{ENV["SANITIZER"]}"
+  ENV["RUSTFLAGS"] = "-Zsanitizer=#{ENV["SANITIZER"]} -C target-cpu=x86-64-v3"
   "cargo +nightly build -Zbuild-std #{cargo_args.join(" ")}".strip
 else
   "cargo build #{cargo_args.join(" ")}".strip

data/ext/rubydex/graph.c

@@ -58,29 +58,6 @@ static VALUE rdxr_graph_index_all(VALUE self, VALUE file_paths) {
     return Qnil;
 }
 
-// Body function for rb_ensure in Graph#declarations
-static VALUE graph_declarations_yield(VALUE args) {
-    VALUE self = rb_ary_entry(args, 0);
-    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
-
-    int64_t id = 0;
-    while (rdx_graph_declarations_iter_next(iter, &id)) {
-        VALUE argv[] = {self, LL2NUM(id)};
-        VALUE handle = rb_class_new_instance(2, argv, cDeclaration);
-        rb_yield(handle);
-    }
-
-    return Qnil;
-}
-
-// Ensure function for rb_ensure in Graph#declarations to always free the iterator
-static VALUE graph_declarations_ensure(VALUE args) {
-    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
-    rdx_graph_declarations_iter_free(iter);
-
-    return Qnil;
-}
-
 // Size function for the declarations enumerator
 static VALUE graph_declarations_size(VALUE self, VALUE _args, VALUE _eobj) {
     void *graph;
@@ -105,7 +82,7 @@ static VALUE rdxr_graph_declarations(VALUE self) {
 
     void *iter = rdx_graph_declarations_iter_new(graph);
     VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
-    rb_ensure(graph_declarations_yield, args, graph_declarations_ensure, args);
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
 
     return self;
 }
@@ -131,7 +108,7 @@ static VALUE rdxr_graph_search(VALUE self, VALUE query) {
     }
 
     VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
-    rb_ensure(graph_declarations_yield, args, graph_declarations_ensure, args);
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
 
     return self;
 }
@@ -141,9 +118,9 @@ static VALUE graph_documents_yield(VALUE args) {
     VALUE self = rb_ary_entry(args, 0);
     void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
 
-    int64_t id = 0;
+    uint64_t id = 0;
     while (rdx_graph_documents_iter_next(iter, &id)) {
-        VALUE argv[] = {self, LL2NUM(id)};
+        VALUE argv[] = {self, ULL2NUM(id)};
         VALUE handle = rb_class_new_instance(2, argv, cDocument);
         rb_yield(handle);
     }
@@ -198,16 +175,16 @@ static VALUE rdxr_graph_aref(VALUE self, VALUE key) {
         rb_raise(rb_eTypeError, "expected String");
     }
 
-    const int64_t *id_ptr = rdx_graph_get_declaration(graph, StringValueCStr(key));
-    if (id_ptr == NULL) {
+    const CDeclaration *decl = rdx_graph_get_declaration(graph, StringValueCStr(key));
+    if (decl == NULL) {
         return Qnil;
     }
 
-    int64_t id = *id_ptr;
-    free_i64(id_ptr);
-    VALUE argv[] = {self, LL2NUM(id)};
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {self, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
 
-    return rb_class_new_instance(2, argv, cDeclaration);
+    return rb_class_new_instance(2, argv, decl_class);
 }
 
 // Body function for rb_ensure for the reference enumerators
@@ -215,11 +192,11 @@ static VALUE graph_references_yield(VALUE args) {
     VALUE self = rb_ary_entry(args, 0);
     void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
 
-    int64_t id = 0;
+    uint64_t id = 0;
     ReferenceKind kind;
     while (rdx_references_iter_next(iter, &id, &kind)) {
         VALUE ref_class = rdxi_reference_class_for_kind(kind);
-        VALUE argv[] = {self, LL2NUM(id)};
+        VALUE argv[] = {self, ULL2NUM(id)};
         VALUE obj = rb_class_new_instance(2, argv, ref_class);
         rb_yield(obj);
     }
@@ -333,7 +310,7 @@ static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nes
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    const int64_t *id_ptr =
+    const CDeclaration *decl =
         rdx_graph_resolve_constant(graph, StringValueCStr(const_name), (const char **)converted_file_paths, length);
 
     for (size_t i = 0; i < length; i++) {
@@ -341,15 +318,44 @@ static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nes
     }
     free(converted_file_paths);
 
-    if (id_ptr == NULL) {
+    if (decl == NULL) {
         return Qnil;
     }
 
-    int64_t id = *id_ptr;
-    free_i64(id_ptr);
-    VALUE argv[] = {self, LL2NUM(id)};
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {self, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
+// Graph#resolve_require_path: (String require_path, Array[String] load_paths) -> Document?
+// Resolves a require path to its Document.
+static VALUE rdxr_graph_resolve_require_path(VALUE self, VALUE require_path, VALUE load_paths) {
+    Check_Type(require_path, T_STRING);
+    rdxi_check_array_of_strings(load_paths);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    const char *path_str = StringValueCStr(require_path);
+
+    size_t paths_len = RARRAY_LEN(load_paths);
+    char **converted_paths = rdxi_str_array_to_char(load_paths, paths_len);
+
+    const uint64_t *uri_id = rdx_resolve_require_path(graph, path_str, (const char **)converted_paths, paths_len);
+
+    for (size_t i = 0; i < paths_len; i++) {
+        free(converted_paths[i]);
+    }
+    free(converted_paths);
+
+    if (uri_id == NULL) {
+        return Qnil;
+    }
 
-    return rb_class_new_instance(2, argv, cDeclaration);
+    VALUE argv[] = {self, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+    return rb_class_new_instance(2, argv, cDocument);
 }
 
 // Graph#diagnostics -> Array[Rubydex::Diagnostic]
@@ -402,4 +408,5 @@ void rdxi_initialize_graph(VALUE mRubydex) {
     rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
     rb_define_method(cGraph, "search", rdxr_graph_search, 1);
     rb_define_method(cGraph, "set_encoding", rdxr_graph_set_encoding, 1);
+    rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
 }

data/ext/rubydex/handle.h

@@ -5,7 +5,7 @@
 
 typedef struct {
     VALUE graph_obj; // Ruby Graph object to keep it alive
-    int64_t id;      // Canonical ID (i64) mapping to a DeclarationId, DefinitionId, UriId, etc. See `ids.rs`.
+    uint64_t id;     // Canonical ID mapping to a DeclarationId, DefinitionId, UriId, etc. See `ids.rs`.
 } HandleData;
 
 static void handle_mark(void *ptr) {
@@ -36,7 +36,7 @@ static VALUE rdxr_handle_initialize(VALUE self, VALUE graph_obj, VALUE id_val) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
     data->graph_obj = graph_obj;
-    data->id = NUM2LL(id_val);
+    data->id = NUM2ULL(id_val);
 
     return self;
 }

data/ext/rubydex/utils.c

@@ -1,4 +1,6 @@
 #include "utils.h"
+#include "declaration.h"
+#include "rustbindings.h"
 
 // Convert a Ruby array of strings into a double char pointer so that we can pass that to Rust.
 // This copies the data so it must be freed
@@ -25,3 +27,26 @@ void rdxi_check_array_of_strings(VALUE array) {
         Check_Type(item, T_STRING);
     }
 }
+
+// Yield body for iterating over declarations
+VALUE rdxi_declarations_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    CDeclaration decl;
+    while (rdx_graph_declarations_iter_next(iter, &decl)) {
+        VALUE decl_class = rdxi_declaration_class_for_kind(decl.kind);
+        VALUE argv[] = {self, ULL2NUM(decl.id)};
+        VALUE handle = rb_class_new_instance(2, argv, decl_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for iterating over declarations to always free the iterator
+VALUE rdxi_declarations_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_graph_declarations_iter_free(iter);
+    return Qnil;
+}

data/ext/rubydex/utils.h

@@ -10,4 +10,10 @@ char **rdxi_str_array_to_char(VALUE array, size_t length);
 // Verify that the Ruby object is an array of strings or raise `TypeError`
 void rdxi_check_array_of_strings(VALUE array);
 
+// Yield body for iterating over declarations
+VALUE rdxi_declarations_yield(VALUE args);
+
+// Ensure function for iterating over declarations to always free the iterator
+VALUE rdxi_declarations_ensure(VALUE args);
+
 #endif // RUBYDEX_UTILS_H

data/lib/rubydex/version.rb

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

data/rust/Cargo.lock

@@ -706,20 +706,41 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "ruby-prism"
-version = "1.6.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2486ac87dae4e4cbc31f5b7a5aa711a51d3c3fcd412d88745a34fa2f4721df8"
+checksum = "3b302f00359d0b5423a600314935ca5f994484e15da2db5345631d28c6e029d6"
 dependencies = [
  "ruby-prism-sys",
  "serde",
- "serde_yaml",
+ "serde_json",
 ]
 
 [[package]]
 name = "ruby-prism-sys"
-version = "1.6.0"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f85fd9571455bdca2b3bf0b2f543cd13ac39d5de0026a8eb2deb94ffd264f00"
+dependencies = [
+ "bindgen",
+ "cc",
+]
+
+[[package]]
+name = "ruby-rbs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0a52a3610111ac0cb06281f0850de2415c1a120d52ec5a6f7da8c52365a56e8"
+dependencies = [
+ "ruby-rbs-sys",
+ "serde",
+ "serde_yaml",
+]
+
+[[package]]
+name = "ruby-rbs-sys"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2646504a4f369cad36018453a60b1b69b8068ae054db40fdb343e224b86d8061"
+checksum = "6d657fad68a7679f97d9572ffcf2bc56f35238979950c7ff14915ea7a05b16ea"
 dependencies = [
  "bindgen",
  "cc",
@@ -742,6 +763,7 @@ dependencies = [
  "predicates",
  "regex",
  "ruby-prism",
+ "ruby-rbs",
  "rubydex",
  "tempfile",
  "url",