mt-lang 0.2.0

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerInlayHints
+        private
+
+      def handle_inlay_hint(params)
+        uri = params.dig('textDocument', 'uri')
+        range = params['range'] || {}
+        start_line = range.dig('start', 'line') || 0
+        start_char = range.dig('start', 'character') || 0
+        end_line = range.dig('end', 'line') || 0
+        end_char = range.dig('end', 'character') || 0
+
+        content = @workspace.get_content(uri)
+        return [] if content && skip_expensive_work_reason(uri, content)
+
+        facts = @workspace.get_facts(uri)
+        tokens = @workspace.get_tokens(uri)
+        return [] unless facts && tokens
+
+        hints = []
+
+        # Parameter-name hints at call sites
+        hints.concat(collect_parameter_name_hints(tokens, facts, start_line, start_char, end_line, end_char))
+
+        # Type annotation hints for inferred locals
+        hints.concat(collect_inferred_type_hints(facts, start_line, start_char, end_line, end_char))
+
+        # Return type hints for inferred return types
+        hints.concat(collect_inferred_return_hints(facts, start_line, start_char, end_line, end_char))
+
+        hints
+      rescue StandardError => e
+        warn "Error in inlayHint handler: #{e.message}"
+        []
+      end
+
+      def collect_parameter_name_hints(tokens, facts, start_line, start_char, end_line, end_char)
+        hints = []
+        i = 0
+        while i < tokens.length - 1
+          callee = tokens[i]
+          next_tok = tokens[i + 1]
+
+          prev_tok = i > 0 ? tokens[i - 1] : nil
+
+          if callee.type == :identifier && prev_tok&.type != :function && prev_tok&.type != :dot
+            binding = nil
+            lparen_index = nil
+
+            if next_tok&.type == :lparen
+              binding = facts.functions[callee.lexeme]
+              lparen_index = i + 1
+            elsif next_tok&.type == :dot
+              member = tokens[i + 2]
+              member_lparen = tokens[i + 3]
+              if member&.type == :identifier && member_lparen&.type == :lparen
+                module_binding = facts.imports[callee.lexeme]
+                binding = module_binding&.functions&.[](member.lexeme)
+                lparen_index = i + 3
+              end
+            end
+
+            if binding && lparen_index
+              arg_starts, closing_index = collect_call_argument_starts(tokens, lparen_index)
+              params_list = binding.type.params
+
+              arg_starts.each_with_index do |arg_tok, index|
+                break if index >= params_list.length
+                next unless position_in_range?(arg_tok.line - 1, arg_tok.column - 1, start_line, start_char, end_line, end_char)
+                next if self_describing_argument_expression?(tokens, arg_tok)
+                param_name = params_list[index].name
+                next if arg_tok.type == :identifier && arg_tok.lexeme == param_name
+
+                hints << {
+                  position: { line: arg_tok.line - 1, character: arg_tok.column - 1 },
+                  label: "#{params_list[index].name}: ",
+                  kind: 2,
+                  paddingRight: true
+                }
+              end
+
+              i = closing_index if closing_index
+            end
+          end
+
+          i += 1
+        end
+        hints
+      end
+
+      def collect_inferred_type_hints(facts, start_line, start_char, end_line, end_char)
+        hints = []
+        collect_local_decls(facts.ast).each do |decl|
+          next unless decl.type.nil?
+          next unless position_in_range?(decl.line - 1, decl.column - 1, start_line, start_char, end_line, end_char)
+
+          binding = facts.values[decl.name]
+          next unless binding
+
+          display_type = describe_type_for_hint(binding.storage_type)
+          next unless display_type
+
+          hints << {
+            position: { line: decl.line - 1, character: decl.column - 1 + decl.name.length },
+            label: ": #{display_type}",
+            kind: 1,
+            paddingRight: false
+          }
+        end
+        hints
+      end
+
+      def collect_inferred_return_hints(facts, start_line, start_char, end_line, end_char)
+        hints = []
+        collect_function_defs(facts.ast).each do |func|
+          next unless func.return_type.nil?
+          next unless position_in_range?(func.line - 1, func.column - 1, start_line, start_char, end_line, end_char)
+
+          binding = facts.functions[func.name]
+          next unless binding
+
+          return_type = binding.type.return_type
+          next unless return_type
+
+          display_type = describe_type_for_hint(return_type)
+          next unless display_type
+          next if display_type == "void"
+
+          label = "-> #{display_type}"
+          hints << {
+            position: { line: func.line - 1, character: func.column - 1 + func.name.length },
+            label: label,
+            kind: 1,
+            paddingRight: false
+          }
+        end
+        hints
+      end
+
+      def collect_local_decls(ast_node)
+        results = []
+        case ast_node
+        when Array
+          ast_node.each { |n| results.concat(collect_local_decls(n)) }
+        when AST::SourceFile
+          ast_node.declarations.each { |d| results.concat(collect_local_decls(d)) }
+        when AST::FunctionDef
+          results.concat(collect_local_decls(ast_node.body)) if ast_node.body
+        when AST::MethodDef
+          results.concat(collect_local_decls(ast_node.body)) if ast_node.body
+        when AST::ExtendingBlock
+          ast_node.methods.each { |m| results.concat(collect_local_decls(m)) }
+        when AST::IfStmt
+          ast_node.branches.each { |b| results.concat(collect_local_decls(b.body)) }
+          results.concat(collect_local_decls(ast_node.else_body)) if ast_node.else_body
+        when AST::MatchStmt
+          ast_node.arms.each { |a| results.concat(collect_local_decls(a.body)) }
+        when AST::ForStmt
+          results.concat(collect_local_decls(ast_node.body))
+        when AST::WhileStmt
+          results.concat(collect_local_decls(ast_node.body))
+        when AST::UnsafeStmt
+          results.concat(collect_local_decls(ast_node.body))
+        when AST::LocalDecl
+          results << ast_node
+        when AST::VariantArm
+          # no body
+        end
+        results
+      end
+
+      def collect_function_defs(ast_node)
+        results = []
+        case ast_node
+        when Array
+          ast_node.each { |n| results.concat(collect_function_defs(n)) }
+        when AST::SourceFile
+          ast_node.declarations.each do |d|
+            case d
+            when AST::FunctionDef
+              results << d
+            when AST::ExtendingBlock
+              results.concat(d.methods)
+            end
+          end
+        end
+        results
+      end
+
+      def describe_type_for_hint(type)
+        return nil unless type
+
+        type.to_s
+      rescue StandardError
+        nil
+      end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerLifecycle
+        private
+
+      def handle_initialize(params)
+        @pull_diagnostics_active = true
+        if @_initialize_called
+          @_indexing_thread&.join rescue nil
+          @_indexing_thread = nil
+          @workspace.reset
+          @format_mode = :tidy
+          @dependency_resolution_mode = :auto
+          @platform_override = nil
+          @diagnostic_report_cache.clear
+          @workspace_diagnostic_cache.clear
+          drain_diagnostics_queue
+          @diagnostics_pending.clear
+          @diagnostics_enqueued.clear
+          @diagnostics_last_scheduled_hash.clear
+          @diagnostics_generation.clear
+          @semantic_tokens_cache.clear
+          @semantic_tokens_delta_cache.clear
+          @fixall_cache.clear
+          @definition_file_token_cache.clear
+          @definition_file_ast_cache.clear
+          MilkTea::Types::Registry.reset!
+        end
+        @_initialize_called = true
+        @root_uri = params['rootUri']
+        @client_capabilities = params['capabilities'] || {}
+        @workspace.workspace_root_path = uri_to_path(@root_uri)
+        negotiate_position_encoding(params)
+        apply_configuration_settings(params['initializationOptions'])
+        apply_configuration_settings(params['settings'])
+        {
+          capabilities: {
+            positionEncoding: @position_encoding,
+            textDocumentSync: {
+              openClose: true,
+              change: 2,
+              save: { includeText: true },
+              willSaveWaitUntil: true
+            },
+            hoverProvider: true,
+            definitionProvider: true,
+            declarationProvider: true,
+            typeDefinitionProvider: true,
+            implementationProvider: true,
+            referencesProvider: true,
+            documentLinkProvider: {
+              resolveProvider: true
+            },
+            documentHighlightProvider: true,
+            documentSymbolProvider: true,
+            documentFormattingProvider: true,
+            documentRangeFormattingProvider: true,
+            foldingRangeProvider: true,
+            callHierarchyProvider: true,
+            typeHierarchyProvider: true,
+            selectionRangeProvider: true,
+            linkedEditingRangeProvider: true,
+            executeCommandProvider: {
+              commands: ['mtc.restartServer']
+            },
+            documentOnTypeFormattingProvider: {
+              firstTriggerCharacter: "\n",
+              moreTriggerCharacter: []
+            },
+            signatureHelpProvider: {
+              triggerCharacters: ['(', ','],
+              retriggerCharacters: [',']
+            },
+            codeActionProvider: {
+              codeActionKinds: ['quickFix', 'source.fixAll']
+            },
+            codeLensProvider: {
+              resolveProvider: true
+            },
+            inlayHintProvider: true,
+            semanticTokensProvider: {
+              legend: {
+                tokenTypes: SEMANTIC_TOKEN_TYPES,
+                tokenModifiers: SEMANTIC_TOKEN_MODIFIERS
+              },
+              full: { delta: true },
+              range: true
+            },
+            completionProvider: {
+              triggerCharacters: ['.', '(', ' '],
+              resolveProvider: true
+            },
+            renameProvider: { prepareProvider: true },
+            workspaceSymbolProvider: true,
+            diagnosticProvider: {
+              interFileDependencies: true,
+              workspaceDiagnostics: true
+            },
+            workspace: {
+              workspaceFolders: {
+                supported: true,
+                changeNotifications: true,
+              },
+              fileOperations: {
+                willRename: {
+                  filters: [{ pattern: { glob: '**/*.mt' }, scheme: 'file' }]
+                }
+              },
+              didChangeWatchedFiles: {
+                dynamicRegistration: true
+              }
+            }
+          }
+        }
+      end
+
+      def negotiate_position_encoding(params)
+        client_encodings = params.dig('capabilities', 'general', 'positionEncodings')
+        if client_encodings.is_a?(Array)
+          @position_encoding = if client_encodings.include?('utf-8')
+                                 'utf-8'
+                               elsif client_encodings.include?('utf-32')
+                                 'utf-32'
+                               else
+                                 'utf-16'
+                               end
+        else
+          @position_encoding = 'utf-16'
+        end
+        Diagnostics.position_encoding = @position_encoding
+      end
+
+      def handle_initialized(_params)
+        pull_client_configuration if @client_capabilities&.dig('workspace', 'configuration')
+        return nil unless @root_uri
+
+        @_indexing_thread = Thread.new do
+          progress = create_progress(title: 'Milk Tea LSP: Indexing workspace', message: 'Scanning source files...')
+          @workspace.index_workspace(@root_uri) { |pct, msg| progress.report(percentage: pct, message: msg) }
+          document_count = @workspace.all_documents.length
+          progress.done(message: "#{document_count} document#{document_count == 1 ? '' : 's'} indexed")
+          log_message(:info, "Milk Tea LSP ready — #{document_count} document#{document_count == 1 ? '' : 's'} indexed")
+          refresh_client_semantic_tokens if document_count > 0
+        end
+        nil
+      end
+
+      def handle_did_change_configuration(params)
+        apply_configuration_settings(params['settings'])
+        nil
+      end
+
+      def handle_cancel_request(params)
+        request_id = params.is_a?(Hash) ? (params['id'] || params[:id]) : nil
+        return nil if request_id.nil?
+
+        @cancelled_requests_mutex.synchronize do
+          @cancelled_request_ids << request_id
+        end
+        nil
+      end
+
+      def handle_did_change_workspace_folders(params)
+        event = params['event'] || {}
+        added = event['added'] || []
+        removed = event['removed'] || []
+
+        removed_uris = removed.filter_map { |folder| folder.is_a?(Hash) ? folder['uri'] : nil }
+        added_uris = added.filter_map { |folder| folder.is_a?(Hash) ? folder['uri'] : nil }
+
+        if removed_uris.include?(@root_uri)
+          @root_uri = added_uris.first
+        elsif @root_uri.nil?
+          @root_uri = added_uris.first
+        end
+
+        @workspace.workspace_root_path = uri_to_path(@root_uri)
+        return nil unless @root_uri
+
+        uris = @workspace.open_document_uris.dup
+        Thread.new do
+          progress = create_progress(title: 'Milk Tea LSP: Reindexing workspace', message: 'Scanning source files...')
+          @workspace.index_workspace(@root_uri) { |pct, msg| progress.report(percentage: pct, message: msg) }
+          doc_count = @workspace.all_documents.length
+          progress.done(message: "#{doc_count} document#{doc_count == 1 ? '' : 's'} indexed")
+
+          uris.each do |uri|
+            schedule_diagnostics(uri, force: true, lint_tier: :full) unless @workspace.background_document?(uri)
+          end
+        end
+        nil
+      end
+
+      def handle_will_rename_files(params)
+        files = params['files'] || []
+        files.each do |file|
+          old_uri = file['oldUri']
+          new_uri = file['newUri']
+          next unless old_uri && new_uri
+
+          @workspace.rename_indexed_file(old_uri, new_uri)
+        end
+        nil
+      end
+
+      def handle_shutdown(_params)
+        stop_diagnostics_workers
+        @workspace.shutdown
+        nil
+      end
+
+      def handle_exit(_params)
+        stop_diagnostics_workers
+        @workspace.shutdown
+        exit(0)
+      end
+
+      SEMANTIC_TOKENS_REFRESH_THROTTLE_MS = 500
+
+      def refresh_client_semantic_tokens
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @semantic_tokens_last_refresh ||= 0.0
+        return if (now - @semantic_tokens_last_refresh) * 1000 < SEMANTIC_TOKENS_REFRESH_THROTTLE_MS
+
+        @semantic_tokens_last_refresh = now
+        @protocol.write_notification('workspace/semanticTokens/refresh', nil)
+      end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerLinkedEditingRange
+        private
+
+        def handle_linked_editing_range(params)
+          uri = params.dig("textDocument", "uri")
+          lsp_line = params.dig("position", "line")
+          lsp_char = params.dig("position", "character")
+          return nil unless uri && lsp_line && lsp_char
+
+          token = @workspace.find_token_at(uri, lsp_line, lsp_char)
+          return nil unless token&.type == :identifier
+
+          facts = @workspace.get_facts(uri)
+          return nil unless facts
+
+          binding_id = rename_target_binding_id(uri, token, lsp_line, lsp_char, facts)
+          return nil unless binding_id
+          return nil unless local_binding_id?(uri, facts, binding_id)
+
+          ranges = scoped_binding_occurrence_ranges(uri, token.lexeme, facts, binding_id, include_declaration: true)
+          return nil if ranges.empty?
+
+          {
+            ranges: ranges.map do |r|
+              {
+                start: { line: r[:line] - 1, character: r[:column] - 1 },
+                end: { line: r[:line] - 1, character: r[:column] - 1 + r[:length] },
+              }
+            end,
+          }
+        rescue StandardError => e
+          warn "Error in linkedEditingRange handler: #{e.message}"
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerOnTypeFormatting
+        private
+
+        BLOCK_INTRODUCING_KEYWORDS = %w[function async editable const public
+          struct enum flags variant union
+          interface if elif else while for match unsafe extending defer when].freeze
+
+        def handle_on_type_formatting(params)
+          ch = params["ch"]
+          return [] unless ch == "\n"
+
+          uri = params["textDocument"]["uri"]
+          position = params["position"]
+          lsp_line = position["line"]
+
+          content = @workspace.get_content(uri)
+          return [] unless content
+
+          lines = content.split("\n", -1)
+          return [] if lsp_line <= 0 || lsp_line >= lines.length
+
+          prev_idx = lsp_line - 1
+          while prev_idx >= 0 && lines[prev_idx].lstrip.empty?
+            prev_idx -= 1
+          end
+          return [] if prev_idx < 0
+
+          prev_line = lines[prev_idx]
+          prev_stripped = prev_line.lstrip
+          prev_indent = prev_line.length - prev_stripped.length
+
+          indent = prev_indent
+          if prev_stripped.end_with?(":")
+            first_word = prev_stripped.split(/\s+/).first.to_s.delete_suffix(":")
+            if BLOCK_INTRODUCING_KEYWORDS.include?(first_word)
+              indent = prev_indent + 4
+            end
+          end
+
+          below_idx = lsp_line + 1
+          while below_idx < lines.length && lines[below_idx].lstrip.empty?
+            below_idx += 1
+          end
+          if below_idx < lines.length
+            below_line = lines[below_idx]
+            below_stripped = below_line.lstrip
+            below_indent = below_line.length - below_stripped.length
+            if below_indent < indent && !below_stripped.end_with?(":")
+              indent = below_indent
+            end
+          end
+
+          current_indent = (lines[lsp_line] || "").length - (lines[lsp_line] || "").lstrip.length
+          return [] if indent == current_indent
+
+          new_text = " " * indent
+          [{
+            range: {
+              start: { line: lsp_line, character: 0 },
+              end: { line: lsp_line, character: current_indent },
+            },
+            newText: new_text,
+          }]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Server
+      module ServerProgress
+        private
+
+        PROGRESS_TOKEN_PREFIX = "mt-lsp-progress"
+
+        def create_progress(title:, message: nil, cancellable: false)
+          token = "#{PROGRESS_TOKEN_PREFIX}-#{next_progress_token_id}"
+
+          @protocol.send_request('window/workDoneProgress/create', { token: token }) do |_result, error|
+            warn "[LSP] client rejected progress token #{token}: #{error}" if error
+          end
+
+          begin_value = { kind: 'begin', title: title, cancellable: cancellable }
+          begin_value[:message] = message if message
+          @protocol.write_notification('$/progress', { token: token, value: begin_value })
+          create_progress_handle(@protocol, token)
+        end
+
+        def create_progress_handle(protocol, token)
+          handle = Object.new
+          handle.define_singleton_method(:report) do |percentage: nil, message: nil|
+            value = { kind: 'report' }
+            value[:percentage] = percentage if percentage
+            value[:message] = message if message
+            protocol.write_notification('$/progress', { token: token, value: value })
+          end
+          handle.define_singleton_method(:done) do |message: nil|
+            value = { kind: 'end' }
+            value[:message] = message if message
+            protocol.write_notification('$/progress', { token: token, value: value })
+          end
+          handle
+        end
+
+        def next_progress_token_id
+          @progress_token_counter ||= 0
+          @progress_token_counter += 1
+        end
+      end
+    end
+  end
+end