Add without_resolution option to skip accumulating pending work

Author: st0012

ext/rubydex/graph.c

@@ -356,6 +356,24 @@ static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
     return Qnil;
 }
 
+// Graph#without_resolution=: (Boolean) -> void
+// Configures the graph to skip accumulating resolution work items
+static VALUE rdxr_graph_set_without_resolution(VALUE self, VALUE without_resolution) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    rdx_graph_set_without_resolution(graph, RTEST(without_resolution));
+    return Qnil;
+}
+
+// Graph#without_resolution?: () -> Boolean
+// Returns whether the graph is configured to skip accumulating resolution work items
+static VALUE rdxr_graph_without_resolution(VALUE self) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    return rdx_graph_without_resolution(graph) ? Qtrue : Qfalse;
+}
+
 // Graph#resolve_constant: (String, Array[String]) -> Declaration?
 // Runs the resolver on a single constant reference to determine what it points to
 static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nesting) {
@@ -498,6 +516,8 @@ 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, "encoding=", rdxr_graph_set_encoding, 1);
+    rb_define_method(cGraph, "without_resolution=", rdxr_graph_set_without_resolution, 1);
+    rb_define_method(cGraph, "without_resolution?", rdxr_graph_without_resolution, 0);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);
 }

lib/rubydex/graph.rb

@@ -16,9 +16,10 @@ class Graph
     #: String
     attr_accessor :workspace_path
 
-    #: (?workspace_path: String) -> void
-    def initialize(workspace_path: Dir.pwd)
+    #: (?workspace_path: String, ?without_resolution: bool) -> void
+    def initialize(workspace_path: Dir.pwd, without_resolution: false)
       @workspace_path = workspace_path
+      self.without_resolution = without_resolution
     end
 
     # Index all files and dependencies of the workspace that exists in `@workspace_path`

rust/rubydex-sys/src/graph_api.rs

@@ -221,6 +221,28 @@ pub unsafe extern "C" fn rdx_graph_set_encoding(pointer: GraphPointer, encoding_
     true
 }
 
+/// Configures the graph to skip accumulating resolution work items.
+///
+/// # Safety
+///
+/// Expects the graph pointer to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_set_without_resolution(pointer: GraphPointer, without_resolution: bool) {
+    with_mut_graph(pointer, |graph| {
+        graph.set_without_resolution(without_resolution);
+    });
+}
+
+/// Returns whether the graph is configured to skip accumulating resolution work items.
+///
+/// # Safety
+///
+/// Expects the graph pointer to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_without_resolution(pointer: GraphPointer) -> bool {
+    with_graph(pointer, |graph| graph.without_resolution())
+}
+
 /// Creates a new iterator over declaration IDs by snapshotting the current set of IDs.
 ///
 /// # Safety

rust/rubydex/src/model/graph.rs

@@ -77,6 +77,10 @@ pub struct Graph {
     /// Used during invalidation to efficiently find affected entities without scanning the full graph.
     name_dependents: IdentityHashMap<NameId, Vec<NameDependent>>,
 
+    /// When true, work items from update/delete are discarded instead of accumulated.
+    /// Use for tools that only need definitions without resolution.
+    without_resolution: bool,
+
     /// Accumulated work items from update/delete operations.
     /// Drained by `take_pending_work()` before resolution.
     pending_work: Vec<Unit>,
@@ -96,6 +100,7 @@ impl Graph {
             position_encoding: Encoding::default(),
             declaration_to_names: IdentityHashMap::default(),
             name_dependents: IdentityHashMap::default(),
+            without_resolution: false,
             pending_work: Vec::default(),
         }
     }
@@ -718,7 +723,9 @@ impl Graph {
         let mut work = Vec::new();
         self.invalidate(Some(&document), None, &mut work);
         self.remove_document_data(&document);
-        self.pending_work.extend(work);
+        if !self.without_resolution {
+            self.pending_work.extend(work);
+        }
         Some(uri_id)
     }
 
@@ -811,7 +818,9 @@ impl Graph {
         }
 
         self.extend(other, &mut work);
-        self.pending_work.extend(work);
+        if !self.without_resolution {
+            self.pending_work.extend(work);
+        }
     }
 
     /// Detaches old definitions from declarations, identifies declarations touched by the
@@ -1140,6 +1149,17 @@ impl Graph {
         false
     }
 
+    /// Configures the graph to skip accumulating resolution work items. Use for tools that only
+    /// need definitions and don't intend to call `resolve()`.
+    pub fn set_without_resolution(&mut self, without_resolution: bool) {
+        self.without_resolution = without_resolution;
+    }
+
+    #[must_use]
+    pub fn without_resolution(&self) -> bool {
+        self.without_resolution
+    }
+
     /// Sets the encoding that should be used for transforming byte offsets into LSP code unit line/column positions
     pub fn set_encoding(&mut self, encoding: Encoding) {
         self.position_encoding = encoding;

test/graph_test.rb

@@ -562,6 +562,49 @@ def test_workspace_paths
 
   private
 
+  def test_without_resolution_prevents_memory_growth
+    with_context do |context|
+      context.write!("foo.rb", <<~RUBY)
+        module Foo
+          CONST = 1
+        end
+      RUBY
+
+      context.write!("bar.rb", <<~RUBY)
+        class Bar
+          Foo::CONST
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new(without_resolution: true)
+      assert(graph.without_resolution?)
+      graph.index_all(context.glob("**/*.rb"))
+
+      # Without resolution, declarations should still be created from definitions
+      refute_nil(graph["Foo"])
+      refute_nil(graph["Bar"])
+
+      # Repeated re-indexing should not accumulate unbounded work
+      10.times do
+        graph.index_source(context.uri_to("bar.rb"), context.absolute_path_to("bar.rb"), <<~RUBY)
+          class Bar
+            Foo::CONST
+          end
+        RUBY
+      end
+
+      # Graph still works for definition lookups
+      refute_nil(graph["Foo"])
+      refute_nil(graph["Bar"])
+    end
+  end
+
+  def test_without_resolution_defaults_to_false
+    graph = Rubydex::Graph.new
+    refute(graph.without_resolution?)
+  end
+
+
   def assert_diagnostics(expected, actual)
     assert_equal(
       expected,