rubik 0.3.0 → 0.3.2

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

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

@@ -16,7 +16,9 @@ module Rubik
 
         private
 
-        def walk_children(node, symbols, impl_type)
+        def walk_children(node, symbols, impl_type, depth: 0)
+          return if depth > 50
+
           (0...node.named_child_count).each do |i|
             child = node.named_child(i)
             case child.kind
@@ -25,13 +27,13 @@ module Rubik
             when "enum_item"
               walk_enum(child, symbols)
             when "impl_item"
-              walk_impl(child, symbols)
+              walk_impl(child, symbols, depth: depth + 1)
             when "function_item"
               walk_function(child, symbols, impl_type)
             when "use_declaration"
               walk_use(child, symbols)
             else
-              walk_children(child, symbols, impl_type)
+              walk_children(child, symbols, impl_type, depth: depth + 1)
             end
           end
         end
@@ -64,12 +66,12 @@ module Rubik
           )
         end
 
-        def walk_impl(node, symbols)
+        def walk_impl(node, symbols, depth: 0)
           type_node = node.child_by_field_name("type")
           impl_name = type_node ? text_for(type_node).strip : nil
 
           body = node.child_by_field_name("body")
-          walk_children(body, symbols, impl_name) if body
+          walk_children(body, symbols, impl_name, depth: depth + 1) if body
         end
 
         def walk_function(node, symbols, impl_type)
@@ -110,13 +112,13 @@ module Rubik
             if n.kind == "call_expression"
               fn = n.child_by_field_name("function")
               if fn
-                fn_text = text_for(fn).split("::").last&.strip
+                fn_text = text_for(fn).strip
                 calls << fn_text if fn_text && !fn_text.empty?
               end
             elsif n.kind == "macro_invocation"
               macro = n.child_by_field_name("macro") || n.named_child(0)
               if macro
-                macro_text = text_for(macro).sub(/!\z/, "").split("::").last&.strip
+                macro_text = text_for(macro).sub(/!\z/, "").strip
                 calls << macro_text if macro_text && !macro_text.empty?
               end
             end

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

@@ -16,12 +16,14 @@ module Rubik
 
         private
 
-        def walk_children(node, symbols, current_class)
+        def walk_children(node, symbols, current_class, depth: 0)
+          return if depth > 50
+
           (0...node.named_child_count).each do |i|
             child = node.named_child(i)
             case child.kind
             when "export_statement"
-              walk_export(child, symbols, current_class)
+              walk_export(child, symbols, current_class, depth: depth + 1)
             when "interface_declaration"
               walk_interface(child, symbols)
             when "enum_declaration"
@@ -35,12 +37,12 @@ module Rubik
             when "import_statement"
               walk_import(child, symbols)
             else
-              walk_children(child, symbols, current_class)
+              walk_children(child, symbols, current_class, depth: depth + 1)
             end
           end
         end
 
-        def walk_export(node, symbols, current_class)
+        def walk_export(node, symbols, current_class, depth:)
           (0...node.named_child_count).each do |i|
             child = node.named_child(i)
             case child.kind
@@ -49,7 +51,7 @@ module Rubik
             when "class_declaration" then walk_class(child, symbols)
             when "function_declaration" then walk_function(child, symbols)
             when "lexical_declaration", "variable_declaration" then walk_variable_declaration(child, symbols)
-            else walk_children(child, symbols, current_class)
+            else walk_children(child, symbols, current_class, depth: depth + 1)
             end
           end
         end

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

@@ -19,14 +19,50 @@ module Rubik
 
         private
 
-        def walk_children(node, symbols)
+        # Zig represents a method receiver as the prefix of a SuffixExpr while
+        # FieldOrFnCall contains only the trailing `.method()` node. Preserve
+        # the full expression so unresolved receiver dispatch is not flattened
+        # into a call to every same-named function.
+        def extract_calls(node, call_kinds = ["call", "call_expression", "invocation"])
+          return super unless call_kinds.include?("FieldOrFnCall")
+
+          calls = []
+          stack = [node]
+          while (current = stack.pop)
+            if current.kind == "FieldOrFnCall"
+              args_node = (0...current.named_child_count).map { |i| current.named_child(i) }
+                                                         .find { |child| child.kind == "FnCallArguments" }
+              if args_node
+                suffix = current.parent
+                start_byte = suffix&.kind == "SuffixExpr" ? suffix.start_byte : current.start_byte
+                fn_text = (@code.byteslice(start_byte...args_node.start_byte) || "").strip
+                calls << fn_text unless fn_text.empty?
+              end
+            elsif current.kind == "SuffixExpr" &&
+                  current.named_child_count >= 2 &&
+                  current.named_child(1)&.kind == "FnCallArguments"
+              fn_text = text_for(current.named_child(0)).strip
+              calls << fn_text unless fn_text.empty?
+            elsif call_kinds.include?(current.kind)
+              fn = current.child_by_field_name("function") || current.child_by_field_name("name") || current.named_child(0)
+              fn_text = text_for(fn).strip if fn
+              calls << fn_text if fn_text && !fn_text.empty?
+            end
+            (0...current.named_child_count).reverse_each { |i| stack.push(current.named_child(i)) }
+          end
+          calls.uniq
+        end
+
+        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
             when "Decl"
               walk_decl(child, symbols)
             else
-              walk_children(child, symbols)
+              walk_children(child, symbols, depth: depth + 1)
             end
           end
         end
@@ -82,11 +118,12 @@ module Rubik
         # Locates the node that owns this Decl's function definition. Zig
         # exposes it under several kind names across grammar versions, so we
         # accept every one we know about rather than only "FnProto".
-        def find_function(node)
+        def find_function(node, depth: 0)
+          return if depth > 50
           return node if FN_KINDS.include?(node.kind)
 
           (0...node.named_child_count).each do |i|
-            found = find_function(node.named_child(i))
+            found = find_function(node.named_child(i), depth: depth + 1)
             return found if found
           end
           nil
@@ -94,11 +131,12 @@ module Rubik
 
         # Walks the subtree for the first identifier node — used as a fallback
         # when the grammar does not expose the function name as a named field.
-        def find_identifier(node)
+        def find_identifier(node, depth: 0)
+          return if depth > 50
           return node if node.kind == "identifier"
 
           (0...node.named_child_count).each do |i|
-            found = find_identifier(node.named_child(i))
+            found = find_identifier(node.named_child(i), depth: depth + 1)
             return found if found
           end
           nil

data/lib/rubik/lsp/client.rb

@@ -4,10 +4,20 @@ require "open3"
 require "json"
 require "uri"
 require_relative "../platform"
+require_relative "../log"
 
 module Rubik
   module LSP
     class Client
+      class RequestError < StandardError
+        attr_reader :reason
+
+        def initialize(reason, message)
+          @reason = reason
+          super(message)
+        end
+      end
+
       SERVERS = {
         "go" => "gopls",
         "rust" => "rust-analyzer",
@@ -30,13 +40,14 @@ module Rubik
         @language = language.to_s.downcase
         @root_dir = Rubik::Platform.expand_path(root_dir)
         cmd = server_cmd || SERVERS[@language]
-        if (cmd.to_s.start_with?("typeprof") || cmd.to_s.start_with?("typescript-language-server")) && !cmd.to_s.include?("--stdio")
+        if cmd.to_s.start_with?("typeprof", "typescript-language-server") && !cmd.to_s.include?("--stdio")
           cmd = "#{cmd} --stdio"
         elsif cmd.to_s.start_with?("solargraph") && !cmd.to_s.include?("stdio")
           cmd = "#{cmd} stdio"
         end
         @server_cmd = cmd
         @running = false
+        @crashed = false
         @req_id = 0
         @stdin = nil
         @stdout = nil
@@ -48,6 +59,7 @@ module Rubik
         @cv = ConditionVariable.new
         @responses = {}
         @pending_requests = {}
+        @reader_failure = nil
         @diagnostics = {}
         @open_documents = {}
         @version_counter = 0
@@ -72,6 +84,7 @@ module Rubik
           @req_id = 0
           @responses.clear
           @pending_requests.clear
+          @reader_failure = nil
           @open_documents.clear
           @diagnostics.clear
           @version_counter = 0
@@ -91,6 +104,7 @@ module Rubik
         @stdin.binmode
         @stdout.binmode
         @running = false
+        @crashed = false
         @reader_alive = false
 
         start_reader_thread
@@ -137,6 +151,10 @@ module Rubik
         true
       end
 
+      def crashed?
+        defined?(@crashed) && @crashed == true
+      end
+
       def reconnect!
         stop if @running
         start
@@ -153,6 +171,7 @@ module Rubik
         end
 
         @running = false
+        @crashed = false
         @reader_alive = false
         # Drain first: its thread may be blocked in gets on @stderr.
         @stderr_drain&.stop
@@ -189,9 +208,8 @@ module Rubik
       def definition(file_path, line, character)
         return { ok: false, error: "LSP server not running" } unless alive?
 
-        abs_path = File.expand_path(file_path, @root_dir)
         res = send_request("textDocument/definition", {
-                             textDocument: { uri: Rubik::Platform.to_file_uri(abs_path) },
+                             textDocument: { uri: document_uri(file_path) },
                              position: { line: line, character: character }
                            })
 
@@ -203,9 +221,8 @@ module Rubik
       def references(file_path, line, character)
         return { ok: false, error: "LSP server not running" } unless alive?
 
-        abs_path = File.expand_path(file_path, @root_dir)
         res = send_request("textDocument/references", {
-                             textDocument: { uri: Rubik::Platform.to_file_uri(abs_path) },
+                             textDocument: { uri: document_uri(file_path) },
                              position: { line: line, character: character },
                              context: { includeDeclaration: true }
                            })
@@ -218,9 +235,8 @@ module Rubik
       def hover(file_path, line, character)
         return { ok: false, error: "LSP server not running" } unless alive?
 
-        abs_path = File.expand_path(file_path, @root_dir)
         res = send_request("textDocument/hover", {
-                             textDocument: { uri: Rubik::Platform.to_file_uri(abs_path) },
+                             textDocument: { uri: document_uri(file_path) },
                              position: { line: line, character: character }
                            })
 
@@ -232,7 +248,7 @@ module Rubik
       def did_open(file_path, content, language_id = @language)
         return false unless alive?
 
-        abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
+        abs_path = normalized_document_path(file_path)
         @mutex.synchronize do
           @version_counter += 1
           @open_documents[abs_path] = @version_counter
@@ -240,7 +256,7 @@ module Rubik
 
         send_notification("textDocument/didOpen", {
                             textDocument: {
-                              uri: Rubik::Platform.to_file_uri(abs_path),
+                              uri: document_uri(abs_path),
                               languageId: language_id.to_s,
                               version: @version_counter,
                               text: content
@@ -254,7 +270,7 @@ module Rubik
       def did_change(file_path, content)
         return false unless alive?
 
-        abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
+        abs_path = normalized_document_path(file_path)
         version = @mutex.synchronize do
           @version_counter += 1
           @open_documents[abs_path] = @version_counter
@@ -266,7 +282,7 @@ module Rubik
 
         send_notification("textDocument/didChange", {
                             textDocument: {
-                              uri: Rubik::Platform.to_file_uri(abs_path),
+                              uri: document_uri(abs_path),
                               version: version
                             },
                             contentChanges: [
@@ -281,11 +297,16 @@ module Rubik
       def did_close(file_path)
         return false unless @running
 
-        abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
-        @mutex.synchronize { @open_documents.delete(abs_path) }
+        abs_path = normalized_document_path(file_path)
+        raw_abs = Rubik::Platform.expand_path(file_path, @root_dir)
+        @mutex.synchronize do
+          @open_documents.delete(abs_path)
+          @open_documents.delete(raw_abs)
+          @open_documents.delete_if { |k, _| Rubik::Platform.path_equal?(k, abs_path) }
+        end
 
         send_notification("textDocument/didClose", {
-                            textDocument: { uri: Rubik::Platform.to_file_uri(abs_path) }
+                            textDocument: { uri: document_uri(abs_path) }
                           })
         true
       rescue StandardError
@@ -295,18 +316,25 @@ module Rubik
       def document_open?(file_path)
         return false if file_path.nil? || file_path.to_s.strip.empty?
 
-        abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
-        @mutex.synchronize { @open_documents.key?(abs_path) }
+        abs_path = normalized_document_path(file_path)
+        raw_abs = Rubik::Platform.expand_path(file_path, @root_dir)
+        @mutex.synchronize do
+          @open_documents.key?(abs_path) ||
+            @open_documents.key?(raw_abs) ||
+            @open_documents.keys.any? { |k| Rubik::Platform.path_equal?(k, abs_path) }
+        end
       rescue ArgumentError
         false
       end
 
       def diagnostics_for(file_path)
-        abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
+        abs_path = normalized_document_path(file_path)
+        raw_abs = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
         root_norm = Rubik::Platform.normalize_path_raw(@root_dir)
-        rel_path = abs_path.start_with?("#{root_norm}/") ? abs_path.delete_prefix("#{root_norm}/") : file_path.to_s.tr("\\", "/")
+        rel_path = raw_abs.start_with?("#{root_norm}/") ? raw_abs.delete_prefix("#{root_norm}/") : file_path.to_s.tr("\\", "/")
         @mutex.synchronize do
           @diagnostics[abs_path] ||
+            @diagnostics[raw_abs] ||
             @diagnostics[rel_path] ||
             @diagnostics[file_path] ||
             @diagnostics.find { |k, _| Rubik::Platform.path_equal?(k, abs_path) }&.last ||
@@ -347,23 +375,30 @@ module Rubik
                 parsed = JSON.parse(body)
                 handle_incoming_message(parsed)
               rescue StandardError => e
-                warn "[LSP::Client] Failed to handle message: #{e.class}: #{e.message}"
+                Rubik::Log.warn(:lsp, "Failed to handle message: #{e.class}: #{e.message}")
               end
             rescue IOError, Errno::EPIPE, Errno::ECONNRESET
               break
             rescue StandardError => e
-              warn "[LSP::Client] Reader loop error: #{e.class}: #{e.message}"
+              Rubik::Log.warn(:lsp, "Reader loop error: #{e.class}: #{e.message}")
               next
             end
           end
         ensure
-          @reader_alive = false
-          @running = false
+          @mutex.synchronize do
+            @crashed = true if @running
+            @reader_alive = false
+            @running = false
+            @reader_failure ||= "LSP response reader stopped before completing the request"
+            @cv.broadcast
+          end
         end
       end
 
       def handle_incoming_message(msg)
-        if msg["id"]
+        if msg.key?("method") && msg.key?("id")
+          handle_server_request(msg)
+        elsif msg.key?("id")
           req_id = msg["id"]
           @mutex.synchronize do
             # Discard late response if request is neither pending nor already tracked
@@ -381,12 +416,14 @@ module Rubik
           params = msg["params"] || {}
           uri = params["uri"].to_s
           raw_path = Rubik::Platform.from_file_uri(uri)
+          norm_path = normalized_document_path(raw_path)
           abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(raw_path, @root_dir))
           root_norm = Rubik::Platform.normalize_path_raw(@root_dir)
           rel_path = abs_path.start_with?("#{root_norm}/") ? abs_path.delete_prefix("#{root_norm}/") : abs_path
           diags = params["diagnostics"] || []
 
           @mutex.synchronize do
+            @diagnostics[norm_path] = diags
             @diagnostics[abs_path] = diags
             @diagnostics[rel_path] = diags
             @diagnostics[raw_path] = diags
@@ -412,15 +449,28 @@ module Rubik
 
       def wait_for_response(req_id, timeout: 5)
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        res = nil
         timed_out = false
+        reader_failure = nil
 
         @mutex.synchronize do
           loop do
             if @responses.key?(req_id)
-              res = @responses.delete(req_id)["result"]
+              response = @responses.delete(req_id)
               @pending_requests.delete(req_id)
-              return res
+              if response.key?("error")
+                error = response["error"] || {}
+                raise RequestError.new(:server_error, error["message"] || "LSP server returned an error")
+              end
+              return response["result"] if response.key?("result")
+
+              raise RequestError.new(:invalid_response, "LSP response did not contain a result")
+            end
+
+            if @reader_failure
+              reader_failure = @reader_failure
+              @responses.delete(req_id)
+              @pending_requests.delete(req_id)
+              break
             end
 
             remaining = timeout - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time)
@@ -442,11 +492,40 @@ module Rubik
           rescue StandardError
             nil
           end
+          raise RequestError.new(:timeout, "LSP request timed out after #{timeout} seconds")
         end
 
+        raise RequestError.new(:reader_failure, reader_failure) if reader_failure
+
         nil
       end
 
+      def normalized_document_path(file_path)
+        path = Rubik::Platform.expand_path(file_path, @root_dir)
+        Rubik::Platform.normalize_path(path)
+      end
+
+      def document_uri(file_path)
+        Rubik::Platform.to_file_uri(normalized_document_path(file_path))
+      end
+
+      def handle_server_request(msg)
+        case msg["method"]
+        when "workspace/configuration"
+          params = msg["params"]
+          items = params.is_a?(Hash) && params["items"].is_a?(Array) ? params["items"] : []
+          write_message({ jsonrpc: "2.0", id: msg["id"], result: items.map { {} } })
+        when "client/registerCapability", "client/unregisterCapability", "window/workDoneProgress/create"
+          write_message({ jsonrpc: "2.0", id: msg["id"], result: nil })
+        else
+          write_message({
+                          jsonrpc: "2.0",
+                          id: msg["id"],
+                          error: { code: -32_601, message: "Method not found: #{msg['method']}" }
+                        })
+        end
+      end
+
       def send_notification(method, params)
         msg = {
           jsonrpc: "2.0",