mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/lsp/server/signature_help.rb

@@ -4,205 +4,203 @@ module MilkTea
   module LSP
     class Server
       module ServerSignatureHelp
-        private
-
-      def signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, name)
-        # 1. Top-level functions
-        if (binding = facts.functions[name])
-          return [binding, name]
-        end
-
-        # 2. Imported module functions (e.g. mod.func(...))
-        facts.imports.each_value do |mod|
-          if (binding = mod.functions[name])
+        def signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, name)
+          # 1. Top-level functions
+          if (binding = facts.functions[name])
             return [binding, name]
           end
-        end
 
-        # 3. Methods — find via dot-receiver resolution
-        dot_recv = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
-        if dot_recv && name
-          if (mod_binding = facts.imports[dot_recv])
-            if (binding = mod_binding.functions[name])
+          # 2. Imported module functions (e.g. mod.func(...))
+          facts.imports.each_value do |mod|
+            if (binding = mod.functions[name])
               return [binding, name]
             end
           end
 
-          if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1) ||
-                               resolve_dot_receiver_value_type(facts, dot_recv.sub(/\[.*\]\z/, ""), lsp_line + 1, lsp_char + 1))
-            methods = methods_for_receiver_type(facts, receiver_type)
-            if (binding = methods[name] || methods["static:#{name}"])
-              return [binding, name]
+          # 3. Methods — find via dot-receiver resolution
+          dot_recv = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
+          if dot_recv && name
+            if (mod_binding = facts.imports[dot_recv])
+              if (binding = mod_binding.functions[name])
+                return [binding, name]
+              end
+            end
+
+            if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1) ||
+                                resolve_dot_receiver_value_type(facts, dot_recv.sub(/\[.*\]\z/, ""), lsp_line + 1, lsp_char + 1))
+              methods = methods_for_receiver_type(facts, receiver_type)
+              if (binding = methods[name] || methods["static:#{name}"])
+                return [binding, name]
+              end
+            end
+
+            if (type_receiver = resolve_type_receiver_info(facts, dot_recv, nil) ||
+                                resolve_type_receiver_info(facts, dot_recv.sub(/\[.*\]\z/, ""), nil))
+              methods = methods_for_receiver_type(facts, type_receiver[:type])
+              if (binding = methods[name] || methods["static:#{name}"])
+                return [binding, name]
+              end
+              if type_receiver[:type].respond_to?(:arms) && (arm = type_receiver[:type].arms[name])
+                if arm.respond_to?(:payload) && arm.payload
+                  return [arm.payload, name]
+                end
+              end
             end
           end
 
-          if (type_receiver = resolve_type_receiver_info(facts, dot_recv, nil) ||
-                              resolve_type_receiver_info(facts, dot_recv.sub(/\[.*\]\z/, ""), nil))
-            methods = methods_for_receiver_type(facts, type_receiver[:type])
+          # 4. Method name directly (e.g. method(...) on `this` in extending block)
+          receiver_type = resolve_this_receiver_type(facts, uri, lsp_line)
+          if receiver_type
+            methods = methods_for_receiver_type(facts, receiver_type)
             if (binding = methods[name] || methods["static:#{name}"])
               return [binding, name]
             end
-            if type_receiver[:type].respond_to?(:arms) && (arm = type_receiver[:type].arms[name])
-              if arm.respond_to?(:payload) && arm.payload
-                return [arm.payload, name]
-              end
+          end
+
+          # 5. Value with callable type (fn/proc)
+          if (val_binding = facts.values[name])
+            if val_binding.type.is_a?(Types::Function)
+              return [val_binding, name]
             end
           end
-        end
 
-        # 4. Method name directly (e.g. method(...) on `this` in extending block)
-        receiver_type = resolve_this_receiver_type(facts, uri, lsp_line)
-        if receiver_type
-          methods = methods_for_receiver_type(facts, receiver_type)
-          if (binding = methods[name] || methods["static:#{name}"])
-            return [binding, name]
+          # 6. Type constructor (struct constructor)
+          if (type = facts.types[name] || facts.imports.each_value.find { |mod| mod.types.key?(name) }&.types&.dig(name))
+            if type.respond_to?(:fields) && !type.fields.empty?
+              return [type, name]
+            end
           end
-        end
 
-        # 5. Value with callable type (fn/proc)
-        if (val_binding = facts.values[name])
-          if val_binding.type.is_a?(Types::Function)
-            return [val_binding, name]
+          # Resolve module-qualified type constructor (mod.Type(...))
+          if name.include?('.')
+            parts = name.split('.', 2)
+            if (mod_binding = facts.imports[parts[0]])
+              if (type = mod_binding.types[parts[1]])
+                if type.respond_to?(:fields) && !type.fields.empty?
+                  return [type, name]
+                end
+              end
+            end
           end
-        end
 
-        # 6. Type constructor (struct constructor)
-        if (type = facts.types[name] || facts.imports.each_value.find { |mod| mod.types.key?(name) }&.types&.dig(name))
-          if type.respond_to?(:fields) && !type.fields.empty?
-            return [type, name]
+          # 7. Builtin callables
+          if BUILTIN_CALL_HOVER_INFO.key?(name)
+            return [{ builtin: name }, name]
           end
+
+          nil
         end
 
-        # Resolve module-qualified type constructor (mod.Type(...))
-        if name.include?('.')
-          parts = name.split('.', 2)
-          if (mod_binding = facts.imports[parts[0]])
-            if (type = mod_binding.types[parts[1]])
-              if type.respond_to?(:fields) && !type.fields.empty?
-                return [type, name]
-              end
+        def resolve_this_receiver_type(facts, uri, lsp_line)
+          ast = @workspace.get_ast(uri)
+          return nil unless ast
+
+          extending = nil
+          each_ast_node(ast) do |node|
+            next unless node.is_a?(AST::ExtendingBlock)
+            if node.line && lsp_line + 1 >= node.line && (!node.respond_to?(:end_line) || !node.end_line || lsp_line + 1 <= node.end_line)
+              extending = node
             end
           end
-        end
 
-        # 7. Builtin callables
-        if BUILTIN_CALL_HOVER_INFO.key?(name)
-          return [{ builtin: name }, name]
+          return nil unless extending
+          facts.types[extending.type_name] ||
+            facts.imports.each_value.find { |mod| mod.types.key?(extending.type_name) }&.types&.dig(extending.type_name)
         end
 
-        nil
-      end
+        def build_signature_from_binding(binding, name, ctx)
+          if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance) || binding.is_a?(Types::VariantArmPayload)
+            fields = binding.is_a?(Types::StructInstance) ? binding.definition.fields : binding.fields
+            params_list = fields.map { |fname, ftype| Types::Registry.parameter(fname, ftype) }
+            return_type_label = binding.is_a?(Types::StructInstance) ? binding.to_s : binding.name
+          elsif binding.respond_to?(:[])
+            builtin_name = binding[:builtin]
+            info = BUILTIN_CALL_HOVER_INFO[builtin_name]
+            return nil unless info
+
+            label = info[:signature].sub(/^builtin /, '')
+            parameters = []
+            return {
+              signatures:      [{ label: label, parameters: parameters }],
+              activeSignature: 0,
+              activeParameter: ctx[:active_parameter],
+            }
+          else
+            return nil unless binding.respond_to?(:type) && binding.type.respond_to?(:params)
+            params_list = binding.type.params
+            return_type_label = binding.type.return_type
+          end
 
-      def resolve_this_receiver_type(facts, uri, lsp_line)
-        ast = @workspace.get_ast(uri)
-        return nil unless ast
+          params_str = format_params(params_list)
+          label = "#{name}(#{params_str}) -> #{return_type_label}"
 
-        extending = nil
-        each_ast_node(ast) do |node|
-          next unless node.is_a?(AST::ExtendingBlock)
-          if node.line && lsp_line + 1 >= node.line && (!node.respond_to?(:end_line) || !node.end_line || lsp_line + 1 <= node.end_line)
-            extending = node
+          parameters = params_list.map do |parameter|
+            { label: "#{parameter.name}: #{parameter.type}" }
           end
-        end
-
-        return nil unless extending
-        facts.types[extending.type_name] ||
-          facts.imports.each_value.find { |mod| mod.types.key?(extending.type_name) }&.types&.dig(extending.type_name)
-      end
 
-      def build_signature_from_binding(binding, name, ctx)
-        if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance) || binding.is_a?(Types::VariantArmPayload)
-          fields = binding.is_a?(Types::StructInstance) ? binding.definition.fields : binding.fields
-          params_list = fields.map { |fname, ftype| Types::Registry.parameter(fname, ftype) }
-          return_type_label = binding.is_a?(Types::StructInstance) ? binding.to_s : binding.name
-        elsif binding.respond_to?(:[])
-          builtin_name = binding[:builtin]
-          info = BUILTIN_CALL_HOVER_INFO[builtin_name]
-          return nil unless info
-
-          label = info[:signature].sub(/^builtin /, '')
-          parameters = []
-          return {
+          {
             signatures:      [{ label: label, parameters: parameters }],
             activeSignature: 0,
             activeParameter: ctx[:active_parameter],
           }
-        else
-          return nil unless binding.respond_to?(:type) && binding.type.respond_to?(:params)
-          params_list = binding.type.params
-          return_type_label = binding.type.return_type
-        end
-
-        params_str = format_params(params_list)
-        label = "#{name}(#{params_str}) -> #{return_type_label}"
-
-        parameters = params_list.map do |parameter|
-          { label: "#{parameter.name}: #{parameter.type}" }
         end
 
-        {
-          signatures:      [{ label: label, parameters: parameters }],
-          activeSignature: 0,
-          activeParameter: ctx[:active_parameter],
-        }
-      end
+        def handle_signature_help(params)
+          stages = new_perf_stages
+          total_start = stages ? monotonic_time : nil
+          uri      = params['textDocument']['uri']
+          lsp_line = params['position']['line']
+          lsp_char = params['position']['character']
+          result_state = 'miss'
 
-      def handle_signature_help(params)
-        stages = new_perf_stages
-        total_start = stages ? monotonic_time : nil
-        uri      = params['textDocument']['uri']
-        lsp_line = params['position']['line']
-        lsp_char = params['position']['character']
-        result_state = 'miss'
+          ctx = measure_perf_stage(stages, 'call_context') { @workspace.find_call_context(uri, lsp_line, lsp_char) }
+          return nil unless ctx
 
-        ctx = measure_perf_stage(stages, 'call_context') { @workspace.find_call_context(uri, lsp_line, lsp_char) }
-        return nil unless ctx
+          facts = measure_perf_stage(stages, 'facts') do
+            @workspace.get_facts(uri, allow_last_good_fallback: allow_hover_last_good_fallback?(uri))
+          end
+          return nil unless facts
 
-        facts = measure_perf_stage(stages, 'facts') do
-          @workspace.get_facts(uri, allow_last_good_fallback: allow_hover_last_good_fallback?(uri))
-        end
-        return nil unless facts
+          binding_info = measure_perf_stage(stages, 'binding') do
+            signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, ctx[:name])
+          end
+          return nil unless binding_info
 
-        binding_info = measure_perf_stage(stages, 'binding') do
-          signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, ctx[:name])
-        end
-        return nil unless binding_info
+          binding, display_name = binding_info
 
-        binding, display_name = binding_info
+          doc_comment = measure_perf_stage(stages, 'docs') do
+            signature_help_doc_comment_for_call(uri, ctx[:name], lsp_line, lsp_char)
+          end
 
-        doc_comment = measure_perf_stage(stages, 'docs') do
-          signature_help_doc_comment_for_call(uri, ctx[:name], lsp_line, lsp_char)
-        end
+          result = measure_perf_stage(stages, 'build') do
+            sig = build_signature_from_binding(binding, display_name, ctx)
 
-        result = measure_perf_stage(stages, 'build') do
-          sig = build_signature_from_binding(binding, display_name, ctx)
+            if sig && sig[:signatures] && (sig_entry = sig[:signatures].first)
+              param_docs = doc_tag_param_descriptions(doc_comment)
+              sig_entry[:parameters]&.each do |param|
+                param_name = param[:label].to_s.split(':').first&.strip
+                if param_name && param_docs.key?(param_name)
+                  param[:documentation] = { kind: 'markdown', value: param_docs[param_name] }
+                end
+              end
 
-          if sig && sig[:signatures] && (sig_entry = sig[:signatures].first)
-            param_docs = doc_tag_param_descriptions(doc_comment)
-            sig_entry[:parameters]&.each do |param|
-              param_name = param[:label].to_s.split(':').first&.strip
-              if param_name && param_docs.key?(param_name)
-                param[:documentation] = { kind: 'markdown', value: param_docs[param_name] }
+              signature_docs = signature_help_markdown_for_doc_comment(doc_comment)
+              unless signature_docs.empty?
+                sig_entry[:documentation] = { kind: 'markdown', value: signature_docs }
               end
             end
 
-            signature_docs = signature_help_markdown_for_doc_comment(doc_comment)
-            unless signature_docs.empty?
-              sig_entry[:documentation] = { kind: 'markdown', value: signature_docs }
-            end
+            sig
           end
-
-          sig
+          result_state = 'hit' if result
+          result
+        rescue StandardError => e
+          result_state = 'error'
+          warn "Error in signatureHelp handler: #{e.message}"
+          nil
+        ensure
+          log_request_stage_breakdown('textDocument/signatureHelp', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
         end
-        result_state = 'hit' if result
-        result
-      rescue StandardError => e
-        result_state = 'error'
-        warn "Error in signatureHelp handler: #{e.message}"
-        nil
-      ensure
-        log_request_stage_breakdown('textDocument/signatureHelp', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
-      end
       end
     end
   end

data/lib/milk_tea/lsp/server/text_documents.rb

@@ -4,121 +4,119 @@ module MilkTea
   module LSP
     class Server
       module ServerTextDocuments
-        private
-
-      def handle_did_open(params)
-        total_start = monotonic_time
-        uri     = params['textDocument']['uri']
-        content = params['textDocument']['text']
-        source = @workspace.document_source(uri) || 'unknown'
-        open_start = monotonic_time
-        open_stats = @workspace.open_document(uri, content)
-        open_ms = elapsed_ms(open_start)
-        @semantic_tokens_cache.delete(uri)
-        @semantic_tokens_delta_cache.delete(uri)
-        @fixall_cache.delete(uri)
-        diagnostics_start = monotonic_time
-        schedule_diagnostics(uri, lint_tier: :full) unless @workspace.background_document?(uri)
-
-        elapsed = elapsed_ms(total_start)
-        short_uri = shorten_uri(uri) || uri
-        facts_detail = if open_stats[:eager_facts]
-                            "on(#{open_stats[:facts_mode] || :unknown})"
-                          else
-                            "off(#{open_stats[:skip_reason] || :unknown})"
-                          end
-        log_perf_breakdown(
-          'textDocument/didOpen',
-          elapsed,
-          "uri=#{short_uri} source=#{source} bytes=#{open_stats[:bytes]} lines=#{open_stats[:lines]} imports=#{open_stats[:import_count]} shared_modules=#{open_stats[:shared_module_cache_size]} eager_facts=#{facts_detail} stages_ms=open:#{open_ms},facts:#{open_stats[:facts_ms] || 0.0},diagnostics_enqueue:#{elapsed_ms(diagnostics_start)}"
-        )
-        nil
-      end
-
-      def handle_did_change(params)
-        uri     = params['textDocument']['uri']
-        changes = params['contentChanges'] || []
-        previous_content = @workspace.get_content(uri)
-
-        @workspace.apply_incremental_changes(uri, changes)
-
-        invalidate_document_caches(uri)
-        current_content = @workspace.get_content(uri)
-        refresh_open_document_dependency_state(uri, previous_content: previous_content, current_content: current_content)
-        schedule_diagnostics(uri, lint_tier: :fast) unless @workspace.background_document?(uri)
-        nil
-      end
-
-      def handle_document_context(params)
-        uri = params.dig('textDocument', 'uri') || params['uri']
-        source = params['source']
-        return nil unless uri && source
-
-        previous_source = @workspace.set_document_source(uri, source)
-        if previous_source == 'background-document' && source != 'background-document' && !@workspace.get_content(uri).empty?
+        def handle_did_open(params)
+          total_start = monotonic_time
+          uri     = params['textDocument']['uri']
+          content = params['textDocument']['text']
+          source = @workspace.document_source(uri) || 'unknown'
+          open_start = monotonic_time
+          open_stats = @workspace.open_document(uri, content)
+          open_ms = elapsed_ms(open_start)
           @semantic_tokens_cache.delete(uri)
           @semantic_tokens_delta_cache.delete(uri)
           @fixall_cache.delete(uri)
-          schedule_diagnostics(uri, force: true, lint_tier: :full)
+          diagnostics_start = monotonic_time
+          schedule_diagnostics(uri, lint_tier: :full) unless @workspace.background_document?(uri)
+
+          elapsed = elapsed_ms(total_start)
+          short_uri = shorten_uri(uri) || uri
+          facts_detail = if open_stats[:eager_facts]
+                              "on(#{open_stats[:facts_mode] || :unknown})"
+                            else
+                              "off(#{open_stats[:skip_reason] || :unknown})"
+                            end
+          log_perf_breakdown(
+            'textDocument/didOpen',
+            elapsed,
+            "uri=#{short_uri} source=#{source} bytes=#{open_stats[:bytes]} lines=#{open_stats[:lines]} imports=#{open_stats[:import_count]} shared_modules=#{open_stats[:shared_module_cache_size]} eager_facts=#{facts_detail} stages_ms=open:#{open_ms},facts:#{open_stats[:facts_ms] || 0.0},diagnostics_enqueue:#{elapsed_ms(diagnostics_start)}"
+          )
+          nil
         end
 
-        nil
-      end
-
-      def handle_did_close(params)
-        uri = params['textDocument']['uri']
-        cancel_diagnostics(uri)
-        @workspace.close_document(uri)
-        invalidate_document_caches(uri)
-        @diagnostic_report_cache.delete(uri)
-        @workspace_diagnostic_cache.delete(uri)
-        refresh_open_document_dependency_state(uri)
-        unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
-          @protocol.write_notification('textDocument/publishDiagnostics', {
-            uri: uri,
-            diagnostics: []
-          })
-        end
-        nil
-      end
+        def handle_did_change(params)
+          uri     = params['textDocument']['uri']
+          changes = params['contentChanges'] || []
+          previous_content = @workspace.get_content(uri)
 
-      def handle_did_save(params)
-        uri = params.dig('textDocument', 'uri')
-        return nil unless uri
+          @workspace.apply_incremental_changes(uri, changes)
 
-        invalidate_document_caches(uri)
-        affected = refresh_open_document_dependency_state(uri)
-        refresh_client_semantic_tokens if affected.any?
-        schedule_diagnostics(uri, force: true, lint_tier: :full) unless @workspace.background_document?(uri)
-        nil
-      end
+          invalidate_document_caches(uri)
+          current_content = @workspace.get_content(uri)
+          refresh_open_document_dependency_state(uri, previous_content: previous_content, current_content: current_content)
+          schedule_diagnostics(uri, lint_tier: :fast) unless @workspace.background_document?(uri)
+          nil
+        end
 
-      def handle_will_save_wait_until(params)
-        uri = params.dig('textDocument', 'uri')
-        return nil unless uri
+        def handle_document_context(params)
+          uri = params.dig('textDocument', 'uri') || params['uri']
+          source = params['source']
+          return nil unless uri && source
+
+          previous_source = @workspace.set_document_source(uri, source)
+          if previous_source == 'background-document' && source != 'background-document' && !@workspace.get_content(uri).empty?
+            @semantic_tokens_cache.delete(uri)
+            @semantic_tokens_delta_cache.delete(uri)
+            @fixall_cache.delete(uri)
+            schedule_diagnostics(uri, force: true, lint_tier: :full)
+          end
 
-        content = @workspace.get_content(uri)
-        return nil if content.nil? || content.empty?
-        return nil if skip_expensive_work_reason(uri, content)
+          nil
+        end
 
-        begin
-          formatted = Timeout.timeout(0.5) do
-            Formatter.format_source(content, path: uri, mode: @format_mode)
+        def handle_did_close(params)
+          uri = params['textDocument']['uri']
+          cancel_diagnostics(uri)
+          @workspace.close_document(uri)
+          invalidate_document_caches(uri)
+          @diagnostic_report_cache.delete(uri)
+          @workspace_diagnostic_cache.delete(uri)
+          refresh_open_document_dependency_state(uri)
+          unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
+            @protocol.write_notification('textDocument/publishDiagnostics', {
+              uri: uri,
+              diagnostics: []
+            })
           end
-          return nil if formatted == content
+          nil
+        end
+
+        def handle_did_save(params)
+          uri = params.dig('textDocument', 'uri')
+          return nil unless uri
 
-          line_count = content.count("\n")
-          [{
-            range: {
-              start: { line: 0, character: 0 },
-              end:   { line: line_count + 1, character: 0 }
-            },
-            newText: formatted
-          }]
-        rescue Timeout::Error, StandardError
+          invalidate_document_caches(uri)
+          affected = refresh_open_document_dependency_state(uri)
+          refresh_client_semantic_tokens if affected.any?
+          schedule_diagnostics(uri, force: true, lint_tier: :full) unless @workspace.background_document?(uri)
           nil
         end
-      end
+
+        def handle_will_save_wait_until(params)
+          uri = params.dig('textDocument', 'uri')
+          return nil unless uri
+
+          content = @workspace.get_content(uri)
+          return nil if content.nil? || content.empty?
+          return nil if skip_expensive_work_reason(uri, content)
+
+          begin
+            formatted = Timeout.timeout(0.5) do
+              Formatter.format_source(content, path: uri, mode: @format_mode)
+            end
+            return nil if formatted == content
+
+            line_count = content.count("\n")
+            [{
+              range: {
+                start: { line: 0, character: 0 },
+                end:   { line: line_count + 1, character: 0 }
+              },
+              newText: formatted
+            }]
+          rescue Timeout::Error, StandardError
+            nil
+          end
+        end
       end
     end
   end

data/lib/milk_tea/lsp/server/type_hierarchy.rb

@@ -4,8 +4,6 @@ module MilkTea
   module LSP
     class Server
       module ServerTypeHierarchy
-        private
-
         TYPE_KIND_MAP = {
           struct: 22,
           enum: 13,
@@ -117,12 +115,12 @@ module MilkTea
         def find_type_info(facts, name)
           if (t = facts.types[name])
             ast = t.respond_to?(:ast_declaration) ? t.ast_declaration : nil
-            return { kind: type_kind_from_object(t), line: ast&.line, column: ast.respond_to?(:column) ? ast.column : 0 }
+            return { kind: type_kind_from_object(t), line: ast&.line, column: ast.column || 0 }
           end
 
           if (t = facts.interfaces[name])
             ast = t.respond_to?(:ast_declaration) ? t.ast_declaration : nil
-            return { kind: :interface, line: ast&.line, column: ast.respond_to?(:column) ? ast.column : 0 }
+            return { kind: :interface, line: ast&.line, column: ast.column || 0 }
           end
 
           nil