mt-lang 0.2.0

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+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])
+            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])
+              return [binding, name]
+            end
+          end
+
+          if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, 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))
+            methods = methods_for_receiver_type(facts, type_receiver[:type])
+            if (binding = methods[name] || methods["static:#{name}"])
+              return [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]
+          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
+
+        # 6. Type constructor (struct constructor)
+        if (type = facts.types[name])
+          if type.respond_to?(:fields) && !type.fields.empty?
+            return [type, name]
+          end
+        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
+            end
+          end
+        end
+
+        # 7. Builtin callables
+        if BUILTIN_CALL_HOVER_INFO.key?(name)
+          return [{ builtin: name }, name]
+        end
+
+        nil
+      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 && node.end_line && lsp_line + 1 >= node.line && lsp_line + 1 <= node.end_line
+            extending = node
+          end
+        end
+
+        return nil unless extending
+        facts.types[extending.type_name]
+      end
+
+      def build_signature_from_binding(binding, name, ctx)
+        if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance)
+          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
+          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'
+
+        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
+
+        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
+
+        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)
+
+          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
+
+            signature_docs = signature_help_markdown_for_doc_comment(doc_comment)
+            unless signature_docs.empty?
+              sig_entry[:documentation] = { kind: 'markdown', value: signature_docs }
+            end
+          end
+
+          sig
+        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
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+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?
+          @semantic_tokens_cache.delete(uri)
+          @semantic_tokens_delta_cache.delete(uri)
+          @fixall_cache.delete(uri)
+          schedule_diagnostics(uri, force: true, lint_tier: :full)
+        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_save(params)
+        uri = params.dig('textDocument', 'uri')
+        return nil unless uri
+
+        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
+
+      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
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerTypeHierarchy
+        private
+
+        TYPE_KIND_MAP = {
+          struct: 22,
+          enum: 13,
+          flags: 13,
+          variant: 13,
+          union: 22,
+          interface: 11,
+        }.freeze
+
+        def handle_prepare_type_hierarchy(params)
+          text_document = params["textDocument"]
+          position = params["position"]
+          uri = text_document["uri"]
+          lsp_line = position["line"]
+          lsp_char = position["character"]
+
+          facts = @workspace.get_facts(uri)
+          return nil unless facts
+
+          token = @workspace.find_token_at(uri, lsp_line, lsp_char)
+          return nil unless token
+          return nil unless token.type == :identifier
+
+          type_name = token.lexeme
+
+          type_entry = type_hierarchy_entry(facts, type_name, uri)
+          return nil unless type_entry
+
+          [type_entry]
+        end
+
+        def handle_supertypes(params)
+          item = params["item"] || params[:item]
+          data = item["data"] || item[:data]
+          return [] unless data.is_a?(Hash) || data.respond_to?(:[])
+
+          type_name = data["name"] || data[:name]
+          uri = data["uri"] || data[:uri]
+          return [] if type_name.to_s.empty?
+
+          facts = @workspace.get_facts(uri)
+          return [] unless facts
+
+          results = []
+          type_obj = facts.types[type_name]
+
+          if type_obj && facts.implemented_interfaces.key?(type_obj)
+            iface_names = facts.implemented_interfaces[type_obj]
+            iface_names.each do |iface|
+              entry = type_hierarchy_entry(facts, iface.name, uri)
+              results << entry if entry
+            end
+          end
+
+          results
+        end
+
+        def handle_subtypes(params)
+          item = params["item"] || params[:item]
+          data = item["data"] || item[:data]
+          return [] unless data.is_a?(Hash) || data.respond_to?(:[])
+
+          type_name = data["name"] || data[:name]
+          return [] if type_name.to_s.empty?
+
+          results = []
+          seen = Set.new
+
+          @workspace.all_documents.each do |doc_uri|
+            facts = @workspace.get_facts(doc_uri)
+            next unless facts
+
+            results_for = collect_subtypes(facts, type_name, doc_uri)
+            results_for.each do |entry|
+              key = [entry[:name], entry[:uri]]
+              next if seen.include?(key)
+
+              seen << key
+              results << entry
+            end
+          end
+
+          results
+        end
+
+        private
+
+        def type_hierarchy_entry(facts, name, uri, kind_override: nil)
+          type_info = find_type_info(facts, name)
+          return nil unless type_info
+
+          kind = kind_override || TYPE_KIND_MAP[type_info[:kind]] || 22
+          range = type_range(type_info)
+
+          {
+            name: name,
+            kind: kind,
+            uri: uri,
+            range: range,
+            selectionRange: range,
+            data: {
+              name: name,
+              uri: uri,
+              kind: type_info[:kind],
+            },
+          }
+        end
+
+        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 }
+          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 }
+          end
+
+          nil
+        end
+
+        def type_kind_from_object(type)
+          case type
+          when Types::Struct then type.is_a?(Types::Union) ? :union : :struct
+          when Types::Variant then :variant
+          when Types::EnumBase then type.respond_to?(:flags?) && type.flags? ? :flags : :enum
+          else :struct
+          end
+        end
+
+        def type_range(type_info)
+          line = type_info[:line] ? type_info[:line] - 1 : 0
+          col = type_info[:column] ? type_info[:column] - 1 : 0
+          {
+            start: { line: line, character: col },
+            end: { line: line, character: col },
+          }
+        end
+
+        def collect_subtypes(facts, target_name, uri)
+          results = []
+
+          facts.implemented_interfaces.each do |type_obj, ifaces|
+            ifaces.each do |iface|
+              next unless iface.respond_to?(:name) && iface.name == target_name
+
+              type_name = type_obj.respond_to?(:name) ? type_obj.name : type_obj.to_s
+              entry = type_hierarchy_entry(facts, type_name, uri)
+              results << entry if entry
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end