rubydex 0.1.0.beta7 → 0.1.0.beta8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cee63a5c5fbdcff32ea743870b83e52958838df77567d9f6e9835a9291ba87c
-  data.tar.gz: 7fc1e83c8121b8f0bea2c794b191c9f1fd2f1eb8c136a1fd6fbe6a288e85a5e8
+  metadata.gz: 9c07115229a5715e4501adce61eefbb4bfe26694f7945736829230d77e97c65a
+  data.tar.gz: 5e845ff2cc4617790785c6cca4f5f67a0cfb02d02d88721062b39fff75e715d1
 SHA512:
-  metadata.gz: f3f4fbb0ed860644b68dc8c770f07b922f27a05f13789a51b00b8bd74d00091a556c43a2772a01c8a47cc60776875056bbac6d6fa1e0574a0b18cd0609b947e1
-  data.tar.gz: df158939d505be5ebec800dfeb486f5da52de1194f0203f119cee3239195ec0c8b2fd42781a881f0cd8f9b133df97757d32697b429f7bf358d6659295c9e219b
+  metadata.gz: 0e5103b95c2123cae03d2f40a1e39ef642aee65b47f99416b034a0f40365bf8535a8829794df393274155bf5e548c44a412457e00fdf8701922e08a9926e3b27
+  data.tar.gz: 478a4a347f1c95210e69e00c2e609abd6ed1c090bae1a5bf30266ade51efc68eaaa294a3f5371d6890497b5d9a782dc0d42c1009c7440d28a1030753a6a03647

data/ext/rubydex/declaration.c

@@ -2,6 +2,7 @@
 #include "definition.h"
 #include "graph.h"
 #include "handle.h"
+#include "reference.h"
 #include "rustbindings.h"
 #include "utils.h"
 
@@ -10,6 +11,7 @@ VALUE cNamespace;
 VALUE cClass;
 VALUE cModule;
 VALUE cSingletonClass;
+VALUE cTodo;
 VALUE cConstant;
 VALUE cConstantAlias;
 VALUE cMethod;
@@ -26,6 +28,8 @@ VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind) {
         return cModule;
     case CDeclarationKind_SingletonClass:
         return cSingletonClass;
+    case CDeclarationKind_Todo:
+        return cTodo;
     case CDeclarationKind_Constant:
         return cConstant;
     case CDeclarationKind_ConstantAlias:
@@ -291,12 +295,49 @@ static VALUE rdxr_declaration_descendants(VALUE self) {
     return self;
 }
 
+// Size function for the Declaration#references enumerator
+static VALUE 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);
+
+    return SIZET2NUM(len);
+}
+
+// Returns an enumerator for all references to this declaration
+//
+// Declaration#references: () -> Enumerator[Reference]
+static VALUE rdxr_declaration_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("references"), 0, NULL, 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_references_iter_new(graph, data->id);
+    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);
+
+    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);
+    cTodo = rb_define_class_under(mRubydex, "Todo", 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);
@@ -309,6 +350,7 @@ 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

data/ext/rubydex/declaration.h

@@ -9,6 +9,7 @@ extern VALUE cNamespace;
 extern VALUE cClass;
 extern VALUE cModule;
 extern VALUE cSingletonClass;
+extern VALUE cTodo;
 extern VALUE cConstant;
 extern VALUE cConstantAlias;
 extern VALUE cMethod;

data/ext/rubydex/graph.c

@@ -228,31 +228,6 @@ static VALUE rdxr_graph_aref(VALUE self, VALUE key) {
     return rb_class_new_instance(2, argv, decl_class);
 }
 
-// Body function for rb_ensure for the reference enumerators
-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));
-
-    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, ULL2NUM(id)};
-        VALUE obj = rb_class_new_instance(2, argv, ref_class);
-        rb_yield(obj);
-    }
-
-    return Qnil;
-}
-
-// Ensure function for rb_ensure for the reference enumerators to always free the iterator
-static VALUE graph_references_ensure(VALUE args) {
-    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
-    rdx_references_iter_free(iter);
-
-    return Qnil;
-}
-
 // Size function for the constant_references enumerator
 static VALUE graph_constant_references_size(VALUE self, VALUE _args, VALUE _eobj) {
     void *graph;
@@ -278,7 +253,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(graph_references_yield, args, graph_references_ensure, args);
+    rb_ensure(rdxi_references_yield, args, rdxi_references_ensure, args);
 
     return self;
 }
@@ -308,7 +283,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(graph_references_yield, args, graph_references_ensure, args);
+    rb_ensure(rdxi_references_yield, args, rdxi_references_ensure, args);
 
     return self;
 }

data/ext/rubydex/utils.c

@@ -1,5 +1,6 @@
 #include "utils.h"
 #include "declaration.h"
+#include "reference.h"
 #include "rustbindings.h"
 
 // Convert a Ruby array of strings into a double char pointer so that we can pass that to Rust.
@@ -50,3 +51,26 @@ VALUE rdxi_declarations_ensure(VALUE args) {
     rdx_graph_declarations_iter_free(iter);
     return Qnil;
 }
+
+// Yield body for iterating over references
+VALUE rdxi_references_yield(VALUE args) {
+    VALUE graph_obj = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    CReference cref;
+    while (rdx_references_iter_next(iter, &cref)) {
+        VALUE ref_class = rdxi_reference_class_for_kind(cref.kind);
+        VALUE argv[] = {graph_obj, ULL2NUM(cref.id)};
+        VALUE obj = rb_class_new_instance(2, argv, ref_class);
+        rb_yield(obj);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for iterating over references to always free the iterator
+VALUE rdxi_references_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_references_iter_free(iter);
+    return Qnil;
+}

data/ext/rubydex/utils.h

@@ -16,4 +16,10 @@ VALUE rdxi_declarations_yield(VALUE args);
 // Ensure function for iterating over declarations to always free the iterator
 VALUE rdxi_declarations_ensure(VALUE args);
 
+// Yield body for iterating over references
+VALUE rdxi_references_yield(VALUE args);
+
+// Ensure function for iterating over references to always free the iterator
+VALUE rdxi_references_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.beta7"
+  VERSION = "0.1.0.beta8"
 end

data/rbi/rubydex.rbi

@@ -1,273 +1,304 @@
 # frozen_string_literal: true
 # typed: strict
 
-module Rubydex
-  class Comment
-    sig { params(string: String, location: Location).void }
-    def initialize(string:, location:); end
+module Rubydex; end
 
-    sig { returns(Location) }
-    def location; end
+class Rubydex::Comment
+  sig { params(string: String, location: Rubydex::Location).void }
+  def initialize(string:, location:); end
 
-    sig { returns(String) }
-    def string; end
-  end
+  sig { returns(Rubydex::Location) }
+  def location; end
 
-  class ConstantReference < Reference
-    sig { returns(Location) }
-    def location; end
+  sig { returns(String) }
+  def string; end
+end
 
-    sig { returns(String) }
-    def name; end
-  end
+class Rubydex::ConstantReference < Rubydex::Reference
+  sig { returns(Rubydex::Location) }
+  def location; end
+
+  sig { returns(String) }
+  def name; end
+end
 
-  class Declaration
-    sig { returns(T::Enumerable[Definition]) }
-    def definitions; end
+class Rubydex::Declaration
+  sig { returns(T::Enumerable[Rubydex::Definition]) }
+  def definitions; end
 
-    sig { returns(String) }
-    def name; end
+  sig { returns(String) }
+  def name; end
 
-    sig { returns(Declaration) }
-    def owner; end
+  sig { returns(Rubydex::Declaration) }
+  def owner; end
 
-    sig { returns(String) }
-    def unqualified_name; end
+  sig { returns(T::Enumerable[Rubydex::Reference]) }
+  def references; end
 
-    class << self
-      private
+  sig { returns(String) }
+  def unqualified_name; end
 
-      def new(*args); end
-    end
+  class << self
+    private
+
+    def new(*args); end
   end
+end
 
-  class GlobalVariable < Declaration; end
-  class InstanceVariable < Declaration; end
-  class Constant < Declaration; end
-  class ConstantAlias < Declaration; end
-  class ClassVariable < Declaration; end
-  class Method < Declaration; end
+class Rubydex::GlobalVariable < Rubydex::Declaration; end
+class Rubydex::InstanceVariable < Rubydex::Declaration; end
+class Rubydex::Constant < Rubydex::Declaration; end
+class Rubydex::ConstantAlias < Rubydex::Declaration; end
+class Rubydex::ClassVariable < Rubydex::Declaration; end
+class Rubydex::Method < Rubydex::Declaration; end
 
-  class Namespace < Declaration
-    sig { returns(T::Enumerable[Namespace]) }
-    def ancestors; end
+class Rubydex::Namespace < Rubydex::Declaration
+  sig { returns(T::Enumerable[Rubydex::Namespace]) }
+  def ancestors; end
 
-    sig { returns(T::Enumerable[Namespace]) }
-    def descendants; end
+  sig { returns(T::Enumerable[Rubydex::Namespace]) }
+  def descendants; end
 
-    sig { params(name: String).returns(T.nilable(Declaration)) }
-    def member(name); end
+  sig { params(name: String).returns(T.nilable(Rubydex::Declaration)) }
+  def member(name); end
 
-    sig { params(name: String, only_inherited: T::Boolean).returns(T.nilable(Declaration)) }
-    def find_member(name, only_inherited: false); end
+  sig { params(name: String, only_inherited: T::Boolean).returns(T.nilable(Rubydex::Declaration)) }
+  def find_member(name, only_inherited: false); end
 
-    sig { returns(T.nilable(SingletonClass)) }
-    def singleton_class; end
-  end
+  sig { returns(T.nilable(Rubydex::SingletonClass)) }
+  def singleton_class; end
+end
 
-  class Class < Namespace; end
-  class Module < Namespace; end
-  class SingletonClass < Namespace; end
+class Rubydex::Class < Rubydex::Namespace; end
+class Rubydex::Module < Rubydex::Namespace; end
+class Rubydex::SingletonClass < Rubydex::Namespace; end
 
-  class Definition
-    sig { returns(T::Array[Comment]) }
-    def comments; end
+class Rubydex::Definition
+  sig { returns(T::Array[Rubydex::Comment]) }
+  def comments; end
 
-    sig { returns(T::Boolean) }
-    def deprecated?; end
+  sig { returns(T::Boolean) }
+  def deprecated?; end
 
-    sig { returns(Location) }
-    def location; end
+  sig { returns(Rubydex::Location) }
+  def location; end
 
-    sig { returns(String) }
-    def name; end
+  sig { returns(String) }
+  def name; end
 
-    sig { returns(T.nilable(Location)) }
-    def name_location; end
+  sig { returns(T.nilable(Rubydex::Location)) }
+  def name_location; end
 
-    class << self
-      private
+  class << self
+    private
 
-      def new(*args); end
-    end
+    def new(*args); end
   end
+end
 
-  class AttrAccessorDefinition < Definition; end
-  class AttrReaderDefinition < Definition; end
-  class AttrWriterDefinition < Definition; end
-  class ClassDefinition < Definition; end
-  class ClassVariableDefinition < Definition; end
-  class ConstantAliasDefinition < Definition; end
-  class ConstantDefinition < Definition; end
-  class GlobalVariableAliasDefinition < Definition; end
-  class GlobalVariableDefinition < Definition; end
-  class InstanceVariableDefinition < Definition; end
-  class MethodAliasDefinition < Definition; end
-  class MethodDefinition < Definition; end
-  class ModuleDefinition < Definition; end
-  class SingletonClassDefinition < Definition; end
-
-  class Diagnostic
-    sig { params(rule: Symbol, message: String, location: Location).void }
-    def initialize(rule:, message:, location:); end
-
-    sig { returns(Location) }
-    def location; end
-
-    sig { returns(String) }
-    def message; end
-
-    sig { returns(Symbol) }
-    def rule; end
-  end
+class Rubydex::AttrAccessorDefinition < Rubydex::Definition; end
+class Rubydex::AttrReaderDefinition < Rubydex::Definition; end
+class Rubydex::AttrWriterDefinition < Rubydex::Definition; end
+class Rubydex::ClassDefinition < Rubydex::Definition; end
+class Rubydex::ClassVariableDefinition < Rubydex::Definition; end
+class Rubydex::ConstantAliasDefinition < Rubydex::Definition; end
+class Rubydex::ConstantDefinition < Rubydex::Definition; end
+class Rubydex::GlobalVariableAliasDefinition < Rubydex::Definition; end
+class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
+class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
+class Rubydex::MethodAliasDefinition < Rubydex::Definition; end
+class Rubydex::MethodDefinition < Rubydex::Definition; end
+class Rubydex::ModuleDefinition < Rubydex::Definition; end
+class Rubydex::SingletonClassDefinition < Rubydex::Definition; end
+
+class Rubydex::Diagnostic
+  sig { params(rule: Symbol, message: String, location: Rubydex::Location).void }
+  def initialize(rule:, message:, location:); end
+
+  sig { returns(Rubydex::Location) }
+  def location; end
+
+  sig { returns(String) }
+  def message; end
+
+  sig { returns(Symbol) }
+  def rule; end
+end
 
-  class Document
-    sig { returns(T::Enumerable[Definition]) }
-    def definitions; end
+class Rubydex::Document
+  sig { returns(T::Enumerable[Rubydex::Definition]) }
+  def definitions; end
 
-    sig { returns(String) }
-    def uri; end
+  sig { returns(String) }
+  def uri; end
 
-    class << self
-      private
+  class << self
+    private
 
-      def new(*args); end
-    end
+    def new(*args); end
   end
+end
 
-  class Error < StandardError; end
+class Rubydex::Error < StandardError; end
 
-  # The global graph representing all declarations and their relationships for the workspace
-  #
-  # Note: this class is partially defined in C to integrate with the Rust backend
-  class Graph
-    IGNORED_DIRECTORIES = T.let(T.unsafe(nil), T::Array[String])
+class Rubydex::Failure
+  sig { params(message: String).void }
+  def initialize(message); end
 
-    sig { params(workspace_path: T.nilable(String)).void }
-    def initialize(workspace_path: nil); end
+  sig { returns(String) }
+  def message; end
+end
 
-    sig { params(fully_qualified_name: String).returns(T.nilable(Declaration)) }
-    def [](fully_qualified_name); end
+class Rubydex::IntegrityFailure < Rubydex::Failure; end
 
-    sig { returns(T::Enumerable[ConstantReference]) }
-    def constant_references; end
+class Rubydex::Graph
+  IGNORED_DIRECTORIES = T.let(T.unsafe(nil), T::Array[String])
 
-    sig { returns(T::Enumerable[Declaration]) }
-    def declarations; end
+  sig { params(workspace_path: T.nilable(String)).void }
+  def initialize(workspace_path: nil); end
 
-    sig { params(uri: String).returns(T.nilable(Document)) }
-    def delete_document(uri); end
+  sig { params(fully_qualified_name: String).returns(T.nilable(Rubydex::Declaration)) }
+  def [](fully_qualified_name); end
 
-    sig { returns(T::Array[Diagnostic]) }
-    def diagnostics; end
+  sig { returns(T::Enumerable[Rubydex::ConstantReference]) }
+  def constant_references; end
 
-    sig { returns(T::Enumerable[Document]) }
-    def documents; end
+  sig { returns(T::Enumerable[Rubydex::Declaration]) }
+  def declarations; end
 
-    sig { params(file_paths: T::Array[String]).returns(T::Array[String]) }
-    def index_all(file_paths); end
+  sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
+  def delete_document(uri); end
 
-    sig { params(uri: String, source: String, language_id: String).void }
-    def index_source(uri, source, language_id); end
+  sig { returns(T::Array[Rubydex::Diagnostic]) }
+  def diagnostics; end
 
-    # Index all files and dependencies of the workspace that exists in `@workspace_path`
-    sig { returns(T::Array[String]) }
-    def index_workspace; end
+  sig { returns(T::Enumerable[Rubydex::Document]) }
+  def documents; end
 
-    sig { returns(T::Enumerable[MethodReference]) }
-    def method_references; end
+  sig { params(file_paths: T::Array[String]).returns(T::Array[String]) }
+  def index_all(file_paths); end
 
-    sig { params(load_paths: T::Array[String]).returns(T::Array[String]) }
-    def require_paths(load_paths); end
+  sig { params(uri: String, source: String, language_id: String).void }
+  def index_source(uri, source, language_id); end
 
-    sig { returns(T.self_type) }
-    def resolve; end
+  # Index all files and dependencies of the workspace that exists in `@workspace_path`
+  sig { returns(T::Array[String]) }
+  def index_workspace; end
 
-    sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(Declaration)) }
-    def resolve_constant(name, nesting); end
+  sig { returns(T::Enumerable[Rubydex::MethodReference]) }
+  def method_references; end
 
-    sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Document)) }
-    def resolve_require_path(require_path, load_paths); end
+  sig { params(load_paths: T::Array[String]).returns(T::Array[String]) }
+  def require_paths(load_paths); end
 
-    sig { params(query: String).returns(T::Enumerable[Declaration]) }
-    def search(query); end
+  sig { returns(T.self_type) }
+  def resolve; end
 
-    sig { params(encoding: String).void }
-    def encoding=(encoding); end
+  sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(Rubydex::Declaration)) }
+  def resolve_constant(name, nesting); end
 
-    sig { returns(String) }
-    def workspace_path; end
+  sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Rubydex::Document)) }
+  def resolve_require_path(require_path, load_paths); end
 
-    sig { params(workspace_path: String).returns(String) }
-    def workspace_path=(workspace_path); end
+  sig { params(query: String).returns(T::Enumerable[Rubydex::Declaration]) }
+  def search(query); end
 
-    sig { returns(T::Array[String]) }
-    def workspace_paths; end
+  sig { params(encoding: String).void }
+  def encoding=(encoding); end
 
-    sig { returns(T::Array[Failure]) }
-    def check_integrity; end
+  sig { returns(String) }
+  def workspace_path; end
 
-    private
+  sig { params(workspace_path: String).returns(String) }
+  def workspace_path=(workspace_path); end
 
-    # Gathers the paths we have to index for all workspace dependencies
-    sig { params(paths: T::Array[String]).void }
-    def add_workspace_dependency_paths(paths); end
+  sig { returns(T::Array[String]) }
+  def workspace_paths; end
+
+  sig { returns(T::Array[Rubydex::Failure]) }
+  def check_integrity; end
+
+  private
+
+  sig { params(paths: T::Array[String]).void }
+  def add_core_rbs_definition_paths(paths); end
+
+  sig { params(paths: T::Array[String]).void }
+  def add_workspace_dependency_paths(paths); end
+end
+
+class Rubydex::DisplayLocation < Rubydex::Location
+  sig { returns([String, Integer, Integer, Integer, Integer]) }
+  def comparable_values; end
+
+  sig { returns(Rubydex::DisplayLocation) }
+  def to_display; end
+
+  sig { returns(String) }
+  def to_s; end
+end
+
+class Rubydex::Location
+  include ::Comparable
+
+  sig do
+    params(
+      uri: String,
+      start_line: Integer,
+      end_line: Integer,
+      start_column: Integer,
+      end_column: Integer,
+    ).void
   end
+  def initialize(uri:, start_line:, end_line:, start_column:, end_column:); end
 
-  class Location
-    include ::Comparable
+  sig { params(other: T.untyped).returns(T.nilable(Integer)) }
+  def <=>(other); end
 
-    sig do
-      params(
-        uri: String,
-        start_line: Integer,
-        end_line: Integer,
-        start_column: Integer,
-        end_column: Integer,
-      ).void
-    end
-    def initialize(uri:, start_line:, end_line:, start_column:, end_column:); end
+  sig { returns([String, Integer, Integer, Integer, Integer]) }
+  def comparable_values; end
 
-    sig { params(other: T.untyped).returns(T.nilable(Integer)) }
-    def <=>(other); end
+  sig { returns(Integer) }
+  def end_column; end
 
-    sig { returns(Integer) }
-    def end_column; end
+  sig { returns(Integer) }
+  def end_line; end
 
-    sig { returns(Integer) }
-    def end_line; end
+  sig { returns(String) }
+  def to_file_path; end
 
-    sig { returns(String) }
-    def to_file_path; end
+  sig { returns(Integer) }
+  def start_column; end
 
-    sig { returns(Integer) }
-    def start_column; end
+  sig { returns(Integer) }
+  def start_line; end
 
-    sig { returns(Integer) }
-    def start_line; end
+  sig { returns(Rubydex::DisplayLocation) }
+  def to_display; end
 
-    sig { returns(String) }
-    def to_s; end
+  sig { returns(String) }
+  def to_s; end
 
-    sig { returns(String) }
-    def uri; end
-  end
+  sig { returns(String) }
+  def uri; end
 
-  class MethodReference < Reference
-    sig { returns(Location) }
-    def location; end
+  class NotFileUriError < StandardError; end
+end
 
-    sig { returns(String) }
-    def name; end
-  end
+class Rubydex::MethodReference < Rubydex::Reference
+  sig { returns(Rubydex::Location) }
+  def location; end
 
-  class Reference
-    class << self
-      private
+  sig { returns(String) }
+  def name; end
+end
 
-      def new(*args); end
-    end
-  end
+class Rubydex::Reference
+  class << self
+    private
 
-  VERSION = T.let(T.unsafe(nil), String)
+    def new(*args); end
+  end
 end
+
+Rubydex::VERSION = T.let(T.unsafe(nil), String)

data/rust/rubydex/src/model/declaration.rs

@@ -60,6 +60,7 @@ macro_rules! all_declarations {
             Declaration::Namespace(Namespace::Class($var)) => $expr,
             Declaration::Namespace(Namespace::Module($var)) => $expr,
             Declaration::Namespace(Namespace::SingletonClass($var)) => $expr,
+            Declaration::Namespace(Namespace::Todo($var)) => $expr,
             Declaration::Constant($var) => $expr,
             Declaration::ConstantAlias($var) => $expr,
             Declaration::Method($var) => $expr,
@@ -76,6 +77,7 @@ macro_rules! all_namespaces {
             Namespace::Class($var) => $expr,
             Namespace::Module($var) => $expr,
             Namespace::SingletonClass($var) => $expr,
+            Namespace::Todo($var) => $expr,
         }
     };
 }
@@ -378,6 +380,7 @@ pub enum Namespace {
     Class(Box<ClassDeclaration>),
     SingletonClass(Box<SingletonClassDeclaration>),
     Module(Box<ModuleDeclaration>),
+    Todo(Box<TodoDeclaration>),
 }
 assert_mem_size!(Namespace, 16);
 
@@ -388,6 +391,7 @@ impl Namespace {
             Namespace::Class(_) => "Class",
             Namespace::SingletonClass(_) => "SingletonClass",
             Namespace::Module(_) => "Module",
+            Namespace::Todo(_) => "<TODO>",
         }
     }
 
@@ -504,7 +508,8 @@ namespace_declaration!(Module, ModuleDeclaration);
 assert_mem_size!(ModuleDeclaration, 224);
 namespace_declaration!(SingletonClass, SingletonClassDeclaration);
 assert_mem_size!(SingletonClassDeclaration, 224);
-
+namespace_declaration!(Todo, TodoDeclaration);
+assert_mem_size!(TodoDeclaration, 224);
 simple_declaration!(ConstantDeclaration);
 assert_mem_size!(ConstantDeclaration, 112);
 simple_declaration!(MethodDeclaration);

data/rust/rubydex/src/model/graph.rs

@@ -84,14 +84,20 @@ impl Graph {
     {
         let declaration_id = DeclarationId::from(&fully_qualified_name);
 
-        let should_promote = self.declarations.get(&declaration_id).is_some_and(|existing| {
-            matches!(existing, Declaration::Constant(_))
-                && matches!(
-                    self.definitions.get(&definition_id),
-                    Some(Definition::Class(_) | Definition::Module(_) | Definition::SingletonClass(_))
-                )
-                && self.all_definitions_promotable(existing)
-        });
+        let is_namespace_definition = matches!(
+            self.definitions.get(&definition_id),
+            Some(Definition::Class(_) | Definition::Module(_) | Definition::SingletonClass(_))
+        );
+
+        let should_promote = is_namespace_definition
+            && self
+                .declarations
+                .get(&declaration_id)
+                .is_some_and(|existing| match existing {
+                    Declaration::Constant(_) => self.all_definitions_promotable(existing),
+                    Declaration::Namespace(Namespace::Todo(_)) => true,
+                    _ => false,
+                });
 
         match self.declarations.entry(declaration_id) {
             Entry::Occupied(mut occupied_entry) => {
@@ -633,6 +639,10 @@ impl Graph {
                 Declaration::Namespace(Namespace::SingletonClass(it)) => {
                     it.add_member(member_str_id, member_declaration_id);
                 }
+                Declaration::Namespace(Namespace::Todo(it)) => it.add_member(member_str_id, member_declaration_id),
+                Declaration::Constant(_) => {
+                    // TODO: temporary hack to avoid crashing on `Struct.new`, `Class.new` and `Module.new`
+                }
                 _ => panic!("Tried to add member to a declaration that isn't a namespace"),
             }
         }

data/rust/rubydex/src/resolution.rs

@@ -7,7 +7,7 @@ use crate::model::{
     declaration::{
         Ancestor, Ancestors, ClassDeclaration, ClassVariableDeclaration, ConstantAliasDeclaration, ConstantDeclaration,
         Declaration, GlobalVariableDeclaration, InstanceVariableDeclaration, MethodDeclaration, ModuleDeclaration,
-        Namespace, SingletonClassDeclaration,
+        Namespace, SingletonClassDeclaration, TodoDeclaration,
     },
     definitions::{Definition, Mixin, Receiver},
     graph::{CLASS_ID, Graph, MODULE_ID, OBJECT_ID},
@@ -1057,12 +1057,60 @@ impl<'a> Resolver<'a> {
     fn name_owner_id(&mut self, name_id: NameId) -> Outcome {
         let name_ref = self.graph.names().get(&name_id).unwrap();
 
-        if let Some(parent_scope) = name_ref.parent_scope().as_ref() {
+        if let Some(&parent_scope) = name_ref.parent_scope().as_ref() {
             // If we have `A::B`, the owner of `B` is whatever `A` resolves to.
             // If `A` is an alias, resolve through to get the actual namespace.
-            match self.resolve_constant_internal(*parent_scope) {
+            // On `Retry`, we don't create a Todo: the parent may still resolve through inheritance once ancestors are
+            // linearized. We only create Todos for `Unresolved` outcomes where the parent is genuinely unknown.
+            match self.resolve_constant_internal(parent_scope) {
                 Outcome::Resolved(id, linearization) => self.resolve_to_primary_namespace(id, linearization),
-                other => other,
+                // Retry or Unresolved(Some(_)) means we might find it later through ancestor linearization
+                Outcome::Retry(id) => Outcome::Retry(id),
+                Outcome::Unresolved(Some(id)) => Outcome::Unresolved(Some(id)),
+                // Only create a Todo when genuinely unresolvable (no pending linearizations)
+                Outcome::Unresolved(None) => {
+                    let parent_name = self.graph.names().get(&parent_scope).unwrap();
+                    let parent_str_id = *parent_name.str();
+                    let parent_has_explicit_prefix = parent_name.parent_scope().as_ref().is_some();
+                    // NLL: borrow of parent_name ends here
+
+                    // For bare names (no explicit `::` prefix), always use OBJECT_ID as the owner.
+                    // Using nesting here would create "Nesting::Bar" instead of "Bar" for a bare `Bar`
+                    // reference, which is incorrect: if `Bar` can't be found anywhere, the placeholder
+                    // should live at the top level so it can be promoted when `module Bar` appears later.
+                    let parent_owner_id = if parent_has_explicit_prefix {
+                        match self.name_owner_id(parent_scope) {
+                            Outcome::Resolved(id, _) => id,
+                            _ => *OBJECT_ID,
+                        }
+                    } else {
+                        *OBJECT_ID
+                    };
+
+                    let fully_qualified_name = if parent_owner_id == *OBJECT_ID {
+                        self.graph.strings().get(&parent_str_id).unwrap().to_string()
+                    } else {
+                        format!(
+                            "{}::{}",
+                            self.graph.declarations().get(&parent_owner_id).unwrap().name(),
+                            self.graph.strings().get(&parent_str_id).unwrap().as_str()
+                        )
+                    };
+
+                    let declaration_id = DeclarationId::from(&fully_qualified_name);
+
+                    if let std::collections::hash_map::Entry::Vacant(e) =
+                        self.graph.declarations_mut().entry(declaration_id)
+                    {
+                        e.insert(Declaration::Namespace(Namespace::Todo(Box::new(TodoDeclaration::new(
+                            fully_qualified_name,
+                            parent_owner_id,
+                        )))));
+                        self.graph.add_member(&parent_owner_id, declaration_id, parent_str_id);
+                    }
+
+                    Outcome::Resolved(declaration_id, None)
+                }
             }
         } else if let Some(nesting_id) = name_ref.nesting()
             && !name_ref.parent_scope().is_top_level()
@@ -1916,9 +1964,12 @@ mod tests {
 
         assert_no_diagnostics!(&context);
 
-        assert_declaration_does_not_exist!(context, "Foo");
-        assert_declaration_does_not_exist!(context, "Foo::Bar");
-        assert_declaration_does_not_exist!(context, "Foo::Bar::Baz");
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+
+        assert_members_eq!(context, "Object", vec!["Foo"]);
+        assert_members_eq!(context, "Foo", vec!["Bar"]);
+        assert_members_eq!(context, "Foo::Bar", vec!["Baz"]);
+        assert_no_members!(context, "Foo::Bar::Baz");
     }
 
     #[test]
@@ -5194,6 +5245,9 @@ mod tests {
               def initialize
                 @instance_ivar = 456
               end
+
+              def bar; end
+              alias new_bar bar
             end
             "
         });
@@ -5206,6 +5260,7 @@ mod tests {
         assert_declaration_exists!(context, "Foo#some_attr()");
         assert_declaration_exists!(context, "Foo::<Foo>#class_method()");
         assert_declaration_exists!(context, "Foo#initialize()");
+        assert_declaration_exists!(context, "Foo#new_bar()");
     }
 
     #[test]
@@ -5261,4 +5316,151 @@ mod tests {
         assert_declaration_does_not_exist!(context, "Foo::<Foo>");
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
     }
+
+    #[test]
+    fn resolve_missing_declaration_to_todo() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo::Bar
+              include Foo::Baz
+
+              def bar; end
+            end
+
+            module Foo::Baz
+              def baz; end
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+
+        assert_members_eq!(context, "Object", vec!["Foo"]);
+        assert_members_eq!(context, "Foo", vec!["Bar", "Baz"]);
+        assert_members_eq!(context, "Foo::Bar", vec!["bar()"]);
+        assert_members_eq!(context, "Foo::Baz", vec!["baz()"]);
+    }
+
+    #[test]
+    fn todo_declaration_promoted_to_real_namespace() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo::Bar
+              def bar; end
+            end
+
+            class Foo
+              def foo; end
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        // Foo was initially created as a Todo (from class Foo::Bar), then promoted to Class
+        assert_declaration_kind_eq!(context, "Foo", "Class");
+
+        assert_members_eq!(context, "Object", vec!["Foo"]);
+        assert_members_eq!(context, "Foo", vec!["Bar", "foo()"]);
+        assert_members_eq!(context, "Foo::Bar", vec!["bar()"]);
+    }
+
+    #[test]
+    fn todo_declaration_promoted_to_real_namespace_incrementally() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///bar.rb", {
+            r"
+            class Foo::Bar
+              def bar; end
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def foo; end
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        // Foo was promoted from Todo to Class after the second resolution
+        assert_declaration_kind_eq!(context, "Foo", "Class");
+
+        assert_members_eq!(context, "Object", vec!["Foo"]);
+        assert_members_eq!(context, "Foo", vec!["Bar", "foo()"]);
+        assert_members_eq!(context, "Foo::Bar", vec!["bar()"]);
+    }
+
+    #[test]
+    fn qualified_name_inside_nesting_resolves_to_top_level() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            module Foo
+              class Bar::Baz
+                def qux; end
+              end
+            end
+
+            module Bar
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Bar", "Module");
+        assert_members_eq!(context, "Bar", vec!["Baz"]);
+        assert_declaration_exists!(context, "Bar::Baz");
+        assert_members_eq!(context, "Bar::Baz", vec!["qux()"]);
+        assert_declaration_does_not_exist!(context, "Foo::Bar");
+    }
+
+    #[test]
+    fn qualified_name_inside_nesting_resolves_when_discovered_incrementally() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///baz.rb", {
+            r"
+            module Foo
+              class Bar::Baz
+                def qux; end
+              end
+            end
+            "
+        });
+        context.resolve();
+
+        // Bar is unknown — a Todo is created at the top level, not "Foo::Bar"
+        assert_declaration_kind_eq!(context, "Bar", "<TODO>");
+        assert_declaration_does_not_exist!(context, "Foo::Bar");
+
+        context.index_uri("file:///bar.rb", {
+            r"
+            module Bar
+            end
+            "
+        });
+        context.resolve();
+
+        // After discovering top-level Bar, the Todo should be promoted and Baz re-homed.
+        assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Bar", "Module");
+        assert_members_eq!(context, "Bar", vec!["Baz"]);
+        assert_members_eq!(context, "Bar::Baz", vec!["qux()"]);
+        assert_declaration_does_not_exist!(context, "Foo::Bar");
+    }
 }

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

@@ -7,6 +7,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::{CReference, ReferenceKind, ReferencesIter};
 use crate::utils;
 use rubydex::model::ids::{DeclarationId, StringId};
 
@@ -22,6 +23,7 @@ pub enum CDeclarationKind {
     GlobalVariable = 6,
     InstanceVariable = 7,
     ClassVariable = 8,
+    Todo = 9,
 }
 
 #[repr(C)]
@@ -51,6 +53,7 @@ impl CDeclaration {
             Declaration::Namespace(Namespace::Class(_)) => CDeclarationKind::Class,
             Declaration::Namespace(Namespace::Module(_)) => CDeclarationKind::Module,
             Declaration::Namespace(Namespace::SingletonClass(_)) => CDeclarationKind::SingletonClass,
+            Declaration::Namespace(Namespace::Todo(_)) => CDeclarationKind::Todo,
             Declaration::Constant(_) => CDeclarationKind::Constant,
             Declaration::ConstantAlias(_) => CDeclarationKind::ConstantAlias,
             Declaration::Method(_) => CDeclarationKind::Method,
@@ -194,13 +197,15 @@ pub unsafe extern "C" fn rdx_declaration_find_member(
             .iter()
             .find_map(|ancestor| match ancestor {
                 Ancestor::Complete(ancestor_id) => {
-                    if *ancestor_id == id {
-                        found_main_namespace = true;
-                        return None;
-                    }
-
-                    if only_inherited && !found_main_namespace {
-                        return None;
+                    // When only_inherited, skip self and prepended modules
+                    if only_inherited {
+                        let is_self = *ancestor_id == id;
+                        if is_self {
+                            found_main_namespace = true;
+                        }
+                        if is_self || !found_main_namespace {
+                            return None;
+                        }
                     }
 
                     let ancestor_decl = graph.declarations().get(ancestor_id).unwrap().as_namespace().unwrap();
@@ -397,3 +402,40 @@ pub unsafe extern "C" fn rdx_declaration_descendants(pointer: GraphPointer, decl
 
     Box::into_raw(Box::new(DeclarationsIter::new(declarations.into_boxed_slice())))
 }
+
+/// Creates a new iterator over references for a given declaration 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_references_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_declaration_references_iter_new(
+    pointer: GraphPointer,
+    decl_id: u64,
+) -> *mut ReferencesIter {
+    with_graph(pointer, |graph| {
+        let decl_id = DeclarationId::new(decl_id);
+
+        let Some(decl) = graph.declarations().get(&decl_id) else {
+            return ReferencesIter::new(Vec::new().into_boxed_slice());
+        };
+
+        let kind = match decl {
+            Declaration::Namespace(_) | Declaration::Constant(_) | Declaration::ConstantAlias(_) => {
+                ReferenceKind::Constant
+            }
+            Declaration::Method(_) => ReferenceKind::Method,
+            Declaration::GlobalVariable(_) | Declaration::InstanceVariable(_) | Declaration::ClassVariable(_) => {
+                return ReferencesIter::new(Vec::new().into_boxed_slice());
+            }
+        };
+
+        let entries: Vec<_> = decl
+            .references()
+            .iter()
+            .map(|ref_id| CReference::new(**ref_id, kind))
+            .collect();
+        ReferencesIter::new(entries.into_boxed_slice())
+    })
+}

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

@@ -2,7 +2,7 @@
 
 use crate::declaration_api::CDeclaration;
 use crate::declaration_api::DeclarationsIter;
-use crate::reference_api::{ReferenceKind, ReferencesIter};
+use crate::reference_api::{CReference, ReferenceKind, ReferencesIter};
 use crate::{name_api, utils};
 use libc::{c_char, c_void};
 use rubydex::indexing::LanguageId;
@@ -452,7 +452,7 @@ pub unsafe extern "C" fn rdx_graph_constant_references_iter_new(pointer: GraphPo
         let refs: Vec<_> = graph
             .constant_references()
             .keys()
-            .map(|id| (**id, ReferenceKind::Constant))
+            .map(|id| CReference::new(**id, ReferenceKind::Constant))
             .collect();
 
         ReferencesIter::new(refs.into_boxed_slice())
@@ -469,7 +469,7 @@ pub unsafe extern "C" fn rdx_graph_method_references_iter_new(pointer: GraphPoin
         let refs: Vec<_> = graph
             .method_references()
             .keys()
-            .map(|id| (**id, ReferenceKind::Method))
+            .map(|id| CReference::new(**id, ReferenceKind::Method))
             .collect();
 
         ReferencesIter::new(refs.into_boxed_slice())

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

@@ -15,16 +15,29 @@ pub enum ReferenceKind {
     Method = 1,
 }
 
-/// Shared iterator over reference (id, kind) pairs
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CReference {
+    id: u64,
+    kind: ReferenceKind,
+}
+
+impl CReference {
+    #[must_use]
+    pub fn new(id: u64, kind: ReferenceKind) -> Self {
+        Self { id, kind }
+    }
+}
+
 #[derive(Debug)]
 pub struct ReferencesIter {
-    pub entries: Box<[(u64, ReferenceKind)]>,
+    pub entries: Box<[CReference]>,
     pub index: usize,
 }
 
 impl ReferencesIter {
     #[must_use]
-    pub fn new(entries: Box<[(u64, ReferenceKind)]>) -> *mut ReferencesIter {
+    pub fn new(entries: Box<[CReference]>) -> *mut ReferencesIter {
         Box::into_raw(Box::new(ReferencesIter { entries, index: 0 }))
     }
 }
@@ -41,23 +54,15 @@ pub unsafe extern "C" fn rdx_references_iter_len(iter: *const ReferencesIter) ->
     unsafe { (&*iter).entries.len() }
 }
 
-/// Advances the iterator and writes the next entry into the provided out params.
+/// Advances the iterator and writes the next entry into `out_ref`.
 /// Returns `true` if an entry was written, or `false` if the iterator is exhausted or inputs are invalid.
 ///
 /// # Safety
 /// - `iter` must be a valid pointer previously returned by `ReferencesIter::new`.
-/// - `out_id` and `out_kind` must be valid, writable pointers.
-///
-/// # Panics
-/// - If the iterator is exhausted or inputs are invalid.
-/// - If the name, URI, start, or end pointers are invalid.
+/// - `out_ref` must be a valid, writable pointer.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_references_iter_next(
-    iter: *mut ReferencesIter,
-    out_id: *mut u64,
-    out_kind: *mut ReferenceKind,
-) -> bool {
-    if iter.is_null() || out_id.is_null() || out_kind.is_null() {
+pub unsafe extern "C" fn rdx_references_iter_next(iter: *mut ReferencesIter, out_ref: *mut CReference) -> bool {
+    if iter.is_null() || out_ref.is_null() {
         return false;
     }
 
@@ -66,11 +71,10 @@ pub unsafe extern "C" fn rdx_references_iter_next(
         return false;
     }
 
-    let (id, kind) = it.entries[it.index];
+    let entry = it.entries[it.index];
     it.index += 1;
     unsafe {
-        *out_id = id;
-        *out_kind = kind;
+        *out_ref = entry;
     }
     true
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta7
+  version: 0.1.0.beta8
 platform: ruby
 authors:
 - Shopify
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-03-04 00:00:00.000000000 Z
+date: 2026-03-05 00:00:00.000000000 Z
 dependencies: []
 description: A high performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -48,7 +48,7 @@ files:
 - lib/rubydex/diagnostic.rb
 - lib/rubydex/failures.rb
 - lib/rubydex/graph.rb
-- lib/rubydex/librubydex_sys.dylib
+- lib/rubydex/librubydex_sys.so
 - lib/rubydex/location.rb
 - lib/rubydex/version.rb
 - rbi/rubydex.rbi
@@ -125,7 +125,7 @@ metadata:
   homepage_uri: https://github.com/Shopify/rubydex
   source_code_uri: https://github.com/Shopify/rubydex
   changelog_uri: https://github.com/Shopify/rubydex/releases
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 3.3.11
 requirements: []
 rubygems_version: 3.4.19
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A high performance static analysis suite for Ruby
 test_files: []