rubik 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b71f1262ecc5dbd53e712da9df276b2fd744a1c797a05917ad4c103ead720b4c
-  data.tar.gz: 9c7d57397bfb5a8dfa4b34846bd51ec7ade3fcade0462cbf7f03d9d00ecb576c
+  metadata.gz: fc6b8b3ff7cb67e302bbb3a74237615515318acde17b8c41193a293dadef7576
+  data.tar.gz: 3c0616b8f9b6544619903234c4595242b95c1998b2602aca584334eaf19fcc5d
 SHA512:
-  metadata.gz: 5994b70d91d9673cb1ea08f1eb39f9f04aa446ea9edcb61bc558d1b81f79825e205a12690dec3b652901d3176061b74012f48bd7a34d6f1b49c6d181219ada33
-  data.tar.gz: 79037bc56238a6eca4f6017e0d23c9b79af836fa5593281cb9005c31750a4f08513d0c78c8ca97c3f83b6cb41643757852a4021778b6c6e2da7a9187e9ea2120
+  metadata.gz: e714d3f5fb612958caba5ed92829af4262b55ac50390d5ed9262cdb8c81143886d613424c13f1fe585c4debead0758469b4aeadea855edcc02d14ef5b9eb5d9b
+  data.tar.gz: cef0f0645353fe8c6f4413c39f6adff50c810c51720022774db779bce54de99a2555396f211a62af336be0be5c4a534f1c14c616a180c3c3344790ca56235772

data/ATTRIBUTION.md

@@ -121,7 +121,7 @@ SOFTWARE.
 | **`strings-ansi`** | Piotr Murach | MIT | ANSI-aware string truncation and alignment for REPL formatters. |
 | **`reline`** | Hiroshi SHIBATA & Ruby Team | Ruby License / BSD-2-Clause | Line-editing, history navigation, autocompletion hooks, and headless terminal adaptation. |
 | **`prism`** | Kevin Newton & Ruby Core Team | MIT | High-performance Ruby parsing and AST extraction ([`Rubik::AST::RubyExtractor`](lib/rubik/ast/ruby_extractor.rb)). |
-| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,700+ unit, integration, and contract tests. |
+| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,800+ unit, integration, and contract tests. |
 | **`rubocop`** | Bozhidar Batsov & contributors | MIT | Static code analysis, style enforcement, and architectural hygiene gates. |
 | **`benchmark`, `logger`, `pstore`, `reline`, `fiddle`** | Ruby core / rubygems teams | Ruby License / BSD-2-Clause | Ruby stdlib gems pinned explicitly in `rubik.gemspec` as they are unbundled from the default set in Ruby 3.4/3.5. |
 

data/CHANGELOG.md

@@ -10,6 +10,56 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 Nothing yet.
 
+## [0.3.2] - 2026-10-21
+
+A reliability patch: LSP requests tell timeouts and crashes apart and
+recover atomically, AST symbol lookup answers precisely, deep
+tree-sitter input no longer overflows the stack, and the tool circuit
+breaker's half-open state actually gates.
+
+### Fixed
+
+- **LSP requests distinguish failures and recover (#214, closes
+  #206, #196):** a successful JSON `null` result is no longer
+  misread as a timeout — hover, definition and references return the
+  proper error outcome; a dead client's recovery is atomic, so
+  concurrent callers all land on the same new client or get a
+  specific recovery error; queries and
+  didOpen/didChange/didClose normalize URIs identically
+  (case-preserving document keys on Windows); server-to-client
+  requests are handled before response correlation;
+  `workspace/configuration` returns empty settings objects and
+  unsupported methods answer `-32601`.
+- **AST symbol lookup is precise (#213, closes #204, #195, #197):**
+  qualified symbol identities are preserved and ambiguous bare names
+  come back with their candidate lists; tree-sitter and Ruby call
+  extraction keep receiver information, so self-recursive calls are
+  retained; symbol search output is sorted and bounded; warmup,
+  extraction errors and argument types are reported explicitly;
+  indexed file keys resolve through symlinked parent paths; the AST
+  cache validates its schema version and guards missing symbol files
+  instead of serving stale lookups.
+- **Tree-sitter walkers cap recursion depth (#203, closes #202 and
+  #191):** Go, C/C++, TypeScript and Zig walkers stop at 50 levels —
+  Zig's `find_function`/`find_identifier` helpers included — so
+  3,000-layer-deep inputs no longer overflow the stack; deeper
+  subtrees are deliberately treated as leaves.
+- **The tool circuit breaker's half-open state is repaired (#215):**
+  half-open admits exactly one probe — the token is consumed on
+  entry and concurrent or subsequent calls are denied while the
+  probe is in flight — and a `cooldown_elapsed?` ArgumentError that
+  broke recovery paths is gone.
+
+### Changed
+
+- **TokenEstimator is ~3.4x faster on tool-call-heavy histories
+  (#216):** `tool_calls` and `tool_schemas` estimation skips the
+  deep UTF-8 clean/re-serialize path, cutting allocations ~90% with
+  bit-for-bit identical output — statusline updates, loop iterations
+  and compaction checks stop paying that tax on every message.
+- **`callers_of` lookups use a Set (#190):** reverse-call indexing
+  drops redundant membership scans.
+
 ## [0.3.1] - 2026-10-19
 
 A hygiene patch: the Truncator honors the budgets you give it across

data/lib/rubik/ast/cache_store.rb

@@ -9,6 +9,8 @@ require_relative "../platform"
 module Rubik
   module AST
     class CacheStore
+      SCHEMA_VERSION = 2
+
       LANGUAGE_MAP = {
         ".rb" => "ruby",
         ".py" => "python",
@@ -46,7 +48,7 @@ module Rubik
         return false unless file_symbols_hash.is_a?(Hash)
 
         data = {
-          "version" => 1,
+          "version" => SCHEMA_VERSION,
           "last_scan" => Time.now.to_i,
           "files" => {}
         }
@@ -106,7 +108,7 @@ module Rubik
 
         content = File.read(target_path)
         data = JSON.parse(content)
-        return {} unless data.is_a?(Hash) && data["files"].is_a?(Hash)
+        return {} unless data.is_a?(Hash) && data["version"] == SCHEMA_VERSION && data["files"].is_a?(Hash)
 
         result = {}
         data["files"].each do |rel_path, cached_info|

data/lib/rubik/ast/graph.rb

@@ -38,13 +38,15 @@ module Rubik
         @file_symbols = Hash.new { |h, k| h[k] = [] }
         @extraction_status = {}
         @mutex = Mutex.new
+        @warmup_generation = 0
+        @warmup_status = { state: :ready, indexed: 0, total: nil, generation: 0 }
       end
 
       # Last extraction status recorded for a file (issue #147): :ok,
       # :partial, :failed, or :unavailable. Lets callers tell "no symbols"
       # apart from "extraction failed" without re-running the extractor.
       def extraction_status(file_path)
-        @mutex.synchronize { @extraction_status[file_path] }
+        @mutex.synchronize { _get_extraction_status_unlocked(file_path) }
       end
 
       def symbols
@@ -54,7 +56,11 @@ module Rubik
       end
 
       def file_symbols
-        @mutex.synchronize { @file_symbols.dup }
+        @mutex.synchronize do
+          @file_symbols.each_with_object(Hash.new { |hash, path| hash[path] = [] }) do |(file_path, symbols), snapshot|
+            snapshot[file_path] = symbols.dup
+          end
+        end
       end
 
       def clear
@@ -63,6 +69,8 @@ module Rubik
           @qualified_symbols.clear
           @file_symbols.clear
           @extraction_status.clear
+          @warmup_generation += 1
+          @warmup_status = { state: :ready, indexed: 0, total: nil, generation: @warmup_generation }
         end
       end
 
@@ -74,8 +82,7 @@ module Rubik
 
       def remove_file(file_path)
         @mutex.synchronize do
-          _remove_file_unlocked(file_path)
-          @extraction_status.delete(file_path)
+          _remove_file_unlocked(file_path, clear_status: true)
         end
       end
 
@@ -106,57 +113,30 @@ module Rubik
       def save_to_cache(cache_store)
         return false unless cache_store
 
-        snapshot = @mutex.synchronize { @file_symbols.dup }
-        cache_store.save(snapshot)
-      end
-
-      # Duplicate-free symbol search: iterates the live map under the mutex
-      # instead of copying it via #symbols (callers only read immutable
-      # attributes, so handing out the Symbol objects is as safe as the
-      # snapshot was — it shared the very same objects).
-      def search_symbols(query)
-        q = query.to_s.downcase
-        @mutex.synchronize do
-          @symbols.values.select { |sym| sym.name.downcase.include?(q) }
-        end
-      end
-
-      # The callers of `symbol_name` are the symbols whose `calls` list
-      # actually references it. `symbol_name` may arrive either as a plain
-      # identifier (e.g. "add") or as a qualified key (e.g.
-      # "rust:src/lib.rs##Config::new") — the `!refs` / callers flow does the
-      # latter. We resolve it to the set of concrete callee spellings it maps
-      # to (plain name plus every qualified key that owns that name), then keep
-      # the symbols whose calls contain one of those spellings. This mirrors the
-      # plain-then-qualified lookup used by #smart_context_for / #symbol_definition
-      # and avoids the previous backwards test, which flagged any symbol merely
-      # mentioning the substring as a caller.
-      def callers_of(symbol_name)
-        @mutex.synchronize do
-          target_names = caller_targets(symbol_name)
-          return [] if target_names.empty?
-
-          @symbols.values.uniq.select do |sym|
-            sym.calls.any? { |c| target_names.include?(c) }
+        snapshot = @mutex.synchronize do
+          @file_symbols.each_with_object({}) do |(file_path, symbols), copy|
+            copy[file_path] = symbols.dup
           end
         end
+        cache_store.save(snapshot)
       end
 
       def smart_context_for(symbol_name)
         @mutex.synchronize do
-          target = @symbols[symbol_name] ||
-                   @qualified_symbols[symbol_name] ||
-                   @symbols.values.find { |s| s.name == symbol_name || s.name.end_with?("##{symbol_name}") }
-          return "" unless target
+          candidates = _symbol_candidate_pairs_unlocked(symbol_name)
+          return "" unless candidates.length == 1
 
+          target = candidates.first.last
           context_blocks = []
           context_blocks << "# Target symbol: #{target.name} (#{target.file}:#{target.line_start}-#{target.line_end})"
           context_blocks << target.body if target.body
 
           target.calls.each do |called_name|
-            matching = @symbols[called_name] ||
-                       @qualified_symbols[called_name] ||
-                       @symbols.values.find { |s| s.name == called_name || s.name.end_with?("##{called_name}") }
+            dep_candidates = _symbol_candidate_pairs_unlocked(called_name).map(&:last)
+            target_scope = _symbol_scope(target.name)
+            matching = dep_candidates.find { |s| s.file && target.file && Rubik::Platform.path_equal?(s.file, target.file) && _symbol_scope(s.name) == target_scope } ||
+                       dep_candidates.find { |s| s.file && target.file && Rubik::Platform.path_equal?(s.file, target.file) } ||
+                       (dep_candidates.first if dep_candidates.length == 1)
             if matching
               context_blocks << "# Dependency signature: #{matching.name}"
               context_blocks << matching.signature
@@ -183,50 +163,8 @@ module Rubik
         end
       end
 
-      def symbol_definition(symbol_name)
-        @mutex.synchronize do
-          target = @symbols[symbol_name] ||
-                   @qualified_symbols[symbol_name] ||
-                   @symbols.values.find do |s|
-                     s.name.downcase == symbol_name.downcase ||
-                       s.name.end_with?("##{symbol_name}") ||
-                       s.name.end_with?(".#{symbol_name}")
-                   end
-          return nil unless target
-
-          {
-            name: target.name,
-            kind: target.kind,
-            file: target.file,
-            line_start: target.line_start,
-            line_end: target.line_end,
-            signature: target.signature,
-            body: target.body,
-            docstring: target.docstring,
-            calls: target.calls
-          }
-        end
-      end
-
       private
 
-      # Concrete callee spellings that a reference to `symbol_name` might use.
-      # `symbol_name` may be a bare identifier ("Config::new") or a qualified key
-      # ("rust:src/lib.rs##Config::new"); we pull the trailing identifier in both
-      # cases and collect every symbol that owns that name so a call site is
-      # matched whether it wrote the bare identifier or the fully-qualified key.
-      # Caller MUST hold @mutex.
-      def caller_targets(symbol_name)
-        bare = symbol_name.split("##").last.to_s
-        return [] if bare.empty?
-
-        names = [bare]
-        @symbols.each_value do |sym|
-          names << sym.name if sym.name == bare || sym.name.end_with?("##{bare}")
-        end
-        names.uniq
-      end
-
       def _index_file_unlocked(file_path, content = nil)
         result = Extractor.extract_result(file_path, content)
         @extraction_status[file_path] = result.status
@@ -259,14 +197,16 @@ module Rubik
         extracted
       end
 
-      def _remove_file_unlocked(file_path)
+      def _remove_file_unlocked(file_path, clear_status: false)
+        if clear_status
+          @extraction_status.delete(file_path)
+          status_key = _matching_key_for_path(@extraction_status, file_path)
+          @extraction_status.delete(status_key) if status_key
+        end
+
         existing = @file_symbols.delete(file_path)
         if existing.nil? || existing.empty?
-          canonical_target = Rubik::Platform.normalize_path(File.expand_path(file_path))
-          matching_key = @file_symbols.keys.find do |k|
-            Rubik::Platform.path_equal?(k, file_path) ||
-              Rubik::Platform.normalize_path(File.expand_path(k)) == canonical_target
-          end
+          matching_key = _matching_key_for_path(@file_symbols, file_path)
           existing = @file_symbols.delete(matching_key) if matching_key
         end
 
@@ -286,13 +226,28 @@ module Rubik
         syms = @file_symbols[file_path]
         return syms if syms && !syms.empty?
 
+        matching_key = _matching_key_for_path(@file_symbols, file_path)
+        (matching_key && @file_symbols[matching_key]) || []
+      end
+
+      def _get_extraction_status_unlocked(file_path)
+        return @extraction_status[file_path] if @extraction_status.key?(file_path)
+
+        matching_key = _matching_key_for_path(@extraction_status, file_path)
+        matching_key ? @extraction_status[matching_key] : nil
+      end
+
+      def _matching_key_for_path(map, file_path)
         canonical_target = Rubik::Platform.normalize_path(File.expand_path(file_path))
-        matching_key = @file_symbols.keys.find do |k|
+        resolved_target = Rubik::Platform.normalize_path(Rubik::Platform.resolved_path_best_effort(file_path))
+        map.keys.find do |k|
           Rubik::Platform.path_equal?(k, file_path) ||
-            Rubik::Platform.normalize_path(File.expand_path(k)) == canonical_target
+            Rubik::Platform.normalize_path(File.expand_path(k)) == canonical_target ||
+            Rubik::Platform.normalize_path(Rubik::Platform.resolved_path_best_effort(k)) == resolved_target
         end
-        (matching_key && @file_symbols[matching_key]) || []
       end
     end
   end
 end
+
+require_relative "graph_extensions"

data/lib/rubik/ast/graph_extensions.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Rubik
+  module AST
+    class SymbolMap
+      def values
+        qualified_values = @qualified_symbols.sort_by { |key, _symbol| key }.map(&:last)
+        qualified_ids = {}.compare_by_identity
+        qualified_values.each { |symbol| qualified_ids[symbol] = true }
+        super.reject { |symbol| qualified_ids.key?(symbol) } + qualified_values
+      end
+
+      def size
+        values.length
+      end
+      alias length size
+
+      def empty?
+        super && @qualified_symbols.empty?
+      end
+    end
+
+    class Graph
+      class AmbiguousSymbolError < StandardError
+        attr_reader :query, :candidates
+
+        def initialize(query, candidates)
+          @query = query
+          @candidates = candidates
+          super("Ambiguous symbol '#{query}'. Use a qualified key. Candidates:\n- #{candidates.join("\n- ")}")
+        end
+      end
+
+      def begin_warmup(total: nil)
+        @mutex.synchronize do
+          @warmup_generation += 1
+          @warmup_status = { state: :warming, indexed: 0, total: total, generation: @warmup_generation }
+          @warmup_generation
+        end
+      end
+
+      def update_warmup(generation, indexed: nil, total: nil)
+        @mutex.synchronize do
+          return false unless generation == @warmup_status[:generation] && @warmup_status[:state] == :warming
+
+          @warmup_status[:indexed] = [indexed, 0].max unless indexed.nil?
+          @warmup_status[:total] = [total, 0].max unless total.nil?
+          true
+        end
+      end
+
+      def finish_warmup(generation, state: :ready)
+        @mutex.synchronize do
+          return false unless generation == @warmup_status[:generation]
+
+          @warmup_status[:state] = state
+          true
+        end
+      end
+
+      def warmup_status
+        @mutex.synchronize { @warmup_status.dup }
+      end
+
+      # Search each qualified definition once and return deterministic relevance order.
+      def search_symbols(query)
+        q = query.to_s.downcase
+        return [] if q.empty?
+
+        @mutex.synchronize do
+          entries = @qualified_symbols.sort_by { |key, _symbol| key }
+          entries = @symbols.map { |name, sym| ["#{sym.file}##{name}", sym] }.sort_by(&:first) if entries.empty?
+          entries.select { |_key, sym| sym.name.downcase.include?(q) }
+                 .sort_by { |key, sym| [_search_rank(sym.name.downcase, q), key] }
+                 .map(&:last)
+        end
+      end
+
+      def symbol_candidates(symbol_name)
+        @mutex.synchronize { _symbol_candidate_pairs_unlocked(symbol_name).map(&:first) }
+      end
+
+      # A bare query with multiple definitions is ambiguous; unresolved receiver
+      # dispatches remain in the call list without being assigned to a symbol.
+      def callers_of(symbol_name)
+        @mutex.synchronize do
+          candidates = _symbol_candidate_pairs_unlocked(symbol_name)
+          return [] if candidates.empty?
+          raise AmbiguousSymbolError.new(symbol_name, candidates.map(&:first)) if candidates.length > 1
+
+          target_key, target = candidates.first
+          target_names = caller_targets(symbol_name)
+          target_name_count = _symbol_candidate_pairs_unlocked(_symbol_leaf(target.name)).length
+          target_scoped_count = _symbol_candidate_pairs_unlocked(target.name).length
+          known_symbols = @qualified_symbols.values.uniq
+          known_symbols = @symbols.values.uniq if known_symbols.empty?
+          known_symbols.select do |caller|
+            caller.calls.any? do |call|
+              _call_matches_symbol?(call, caller, target, target_key, target_names, target_name_count, target_scoped_count)
+            end
+          end
+        end
+      end
+
+      def symbol_definition(symbol_name)
+        @mutex.synchronize do
+          candidates = _symbol_candidate_pairs_unlocked(symbol_name)
+          return nil unless candidates.length == 1
+
+          target = candidates.first.last
+          {
+            name: target.name,
+            kind: target.kind,
+            file: target.file,
+            line_start: target.line_start,
+            line_end: target.line_end,
+            signature: target.signature,
+            body: target.body,
+            docstring: target.docstring,
+            calls: target.calls
+          }
+        end
+      end
+
+      private
+
+      def _search_rank(name, query)
+        return 0 if name == query
+        return 1 if name.start_with?(query)
+
+        2
+      end
+
+      def caller_targets(symbol_name)
+        candidates = _symbol_candidate_pairs_unlocked(symbol_name)
+        return [] unless candidates.length == 1
+
+        key, symbol = candidates.first
+        [key, symbol.name].uniq
+      end
+
+      def _symbol_candidate_pairs_unlocked(symbol_name)
+        query = symbol_name.to_s
+        return [] if query.empty?
+
+        exact = @qualified_symbols[query]
+        return [[query, exact]] if exact
+
+        pairs = @qualified_symbols.to_a
+        pairs = @symbols.map { |name, sym| ["#{sym.file}##{name}", sym] } if pairs.empty?
+        folded = query.downcase
+        matched = pairs.select do |_key, symbol|
+          name = symbol.name.to_s
+          leaf = _symbol_leaf(name)
+          name.downcase == folded || leaf.downcase == folded ||
+            name.downcase.end_with?("##{folded}", ".#{folded}", "::#{folded}")
+        end
+        matched.sort_by(&:first).uniq(&:first)
+      end
+
+      def _symbol_leaf(name)
+        name.to_s.split(/[#.:]/).last.to_s
+      end
+
+      def _symbol_scope(name)
+        value = name.to_s
+        separator = [value.rindex("#"), value.rindex("."), value.rindex("::")].compact.max
+        separator ? value[0...separator] : nil
+      end
+
+      def _normalized_call_name(name)
+        name.to_s.gsub("::", "#").gsub(".", "#").sub(/!\z/, "")
+      end
+
+      def _call_matches_symbol?(call, caller, target, target_key, target_names, target_name_count, target_scoped_count = target_name_count)
+        value = call.to_s.strip.sub(/!\z/, "")
+        normalized = _normalized_call_name(value)
+        target_name = _normalized_call_name(target.name)
+        same_file = caller.file && target.file && Rubik::Platform.path_equal?(caller.file, target.file)
+        return true if value == target_key
+        return true if normalized == target_name && (target_scoped_count == 1 || same_file)
+
+        leaf = _symbol_leaf(value)
+        return false unless leaf == _symbol_leaf(target.name)
+        return true if target_name_count == 1 && !value.match?(/[.#:]|->/)
+
+        call_scope = _symbol_scope(value)
+        target_scope = _symbol_scope(target.name)
+        caller_scope = _symbol_scope(caller.name)
+        return true if call_scope == target_scope && call_scope && same_file
+
+        caller_recv = caller_scope && caller_scope[/\A\(\s*([A-Za-z_]\w*)\b/, 1]
+        self_scopes = ["self", "this", caller_recv].compact
+        return true if self_scopes.include?(call_scope) && caller_scope == target_scope && same_file
+
+        # Bare calls are local to one lexical scope; unknown receiver calls stay unresolved.
+        lexical_scope_matches = target_scope ? caller_scope == target_scope : caller_scope.nil?
+        !value.match?(/[.#:]|->/) && target_names.include?(target.name) && same_file && lexical_scope_matches
+      end
+    end
+  end
+end

data/lib/rubik/ast/ruby_extractor.rb

@@ -141,14 +141,19 @@ module Rubik
         end
       end
 
-      def extract_calls_from_node(node, self_name)
+      def extract_calls_from_node(node, _self_name)
         calls = []
         queue = [node]
 
         while (curr = queue.pop)
           if curr.is_a?(Prism::CallNode)
             cname = curr.name.to_s
-            calls << cname unless cname == self_name || ["require", "require_relative", "raise", "puts", "p", "print"].include?(cname)
+            if curr.receiver
+              receiver = curr.receiver.slice.to_s
+              operator = curr.call_operator || "."
+              cname = "#{receiver}#{operator}#{cname}"
+            end
+            calls << cname unless ["require", "require_relative", "raise", "puts", "p", "print"].include?(cname)
           end
           queue.concat(curr.compact_child_nodes) if curr.respond_to?(:compact_child_nodes)
         end
@@ -187,7 +192,7 @@ module Rubik
             calls = []
             calls_src.scan(/\b([a-z_][a-zA-Z0-9_]*)\s*\(/) do |m|
               c = m[0]
-              calls << c unless c == method_name || EXCLUDED_CALLS.include?(c) || calls.include?(c)
+              calls << c unless EXCLUDED_CALLS.include?(c) || calls.include?(c)
             end
 
             symbols << Symbol.new(

data/lib/rubik/ast/symbol.rb

@@ -45,6 +45,13 @@ module Rubik
         end
       end
 
+      def body_available?
+        return true if @body || @body_loader
+        return false if @file.nil? || !File.exist?(@file)
+
+        true
+      end
+
       def self.read_source_range(file, l_start, l_end)
         return nil unless file && l_start && File.exist?(file)
 

data/lib/rubik/ast/treesitter/base_walker.rb

@@ -79,9 +79,10 @@ module Rubik
             if call_kinds.include?(n.kind)
               fn = n.child_by_field_name("function") || n.child_by_field_name("name") || n.named_child(0)
               if fn
-                fn_text = text_for(fn).strip
-                # Extract clean identifier name (e.g. "fmt.Println" -> "Println", "obj.method" -> "method")
-                fn_name = fn_text.split(".").last.to_s.split("::").last.to_s.strip
+                # Keep receiver and namespace text. Stripping this to a bare
+                # method name made dynamic dispatch look like a call to every
+                # same-named definition in the graph.
+                fn_name = text_for(fn).strip
                 calls << fn_name if fn_name && !fn_name.empty?
               end
             end

data/lib/rubik/ast/treesitter/c_walker.rb

@@ -49,7 +49,9 @@ module Rubik
         # `scope` is the enclosing declaration path (namespaces, then the
         # innermost class, outermost first); `member` marks a class body so
         # declarations are read as member declarations.
-        def walk_children(node, symbols, scope, member:)
+        def walk_children(node, symbols, scope, member:, depth: 0)
+          return if depth > 50
+
           (0...node.named_child_count).each do |i|
             child = node.named_child(i)
             case child.kind
@@ -58,9 +60,9 @@ module Rubik
             when "type_definition"
               walk_typedef(child, symbols, scope)
             when *RECORD_KINDS.keys
-              walk_record(child, symbols, scope)
+              walk_record(child, symbols, scope, depth: depth + 1)
             when "namespace_definition"
-              walk_namespace(child, symbols, scope)
+              walk_namespace(child, symbols, scope, depth: depth + 1)
             when "function_definition"
               walk_function(child, symbols, scope, member: member)
             when "field_declaration", "declaration"
@@ -69,7 +71,7 @@ module Rubik
               # Plain recursion also unwraps template_declaration nodes (their
               # inner class/function is walked in place) and linkage
               # specifications.
-              walk_children(child, symbols, scope, member: member)
+              walk_children(child, symbols, scope, member: member, depth: depth + 1)
             end
           end
         end
@@ -104,7 +106,7 @@ module Rubik
           )
         end
 
-        def walk_record(node, symbols, scope)
+        def walk_record(node, symbols, scope, depth:)
           name_node = node.child_by_field_name("name")
           return unless name_node
 
@@ -122,16 +124,16 @@ module Rubik
           )
 
           body = node.child_by_field_name("body")
-          walk_children(body, symbols, scope + [name], member: true) if body
+          walk_children(body, symbols, scope + [name], member: true, depth: depth + 1) if body
         end
 
         # Namespace names extend the qualification path; everything inside is
         # walked with the namespace prefix (app::run, app::Widget#run).
-        def walk_namespace(node, symbols, scope)
+        def walk_namespace(node, symbols, scope, depth:)
           name_node = node.child_by_field_name("name")
           ns_scope = name_node ? scope + [text_for(name_node).strip] : scope
           body = node.child_by_field_name("body")
-          walk_children(body, symbols, ns_scope, member: false) if body
+          walk_children(body, symbols, ns_scope, member: false, depth: depth + 1) if body
         end
 
         def walk_function(node, symbols, scope, member:)

data/lib/rubik/ast/treesitter/go_walker.rb

@@ -16,7 +16,9 @@ module Rubik
 
         private
 
-        def walk_children(node, symbols)
+        def walk_children(node, symbols, depth: 0)
+          return if depth > 50
+
           (0...node.named_child_count).each do |i|
             child = node.named_child(i)
             case child.kind
@@ -31,7 +33,7 @@ module Rubik
             when "import_declaration"
               walk_import(child, symbols)
             else
-              walk_children(child, symbols)
+              walk_children(child, symbols, depth: depth + 1)
             end
           end
         end