mt-lang 0.2.0

data/lib/milk_tea/lsp/diagnostics.rb

@@ -0,0 +1,611 @@
+# frozen_string_literal: true
+
+require 'cgi/escape'
+require 'uri'
+
+module MilkTea
+  module LSP
+    # Collects parse and semantic errors and formats them as LSP Diagnostics
+    class Diagnostics
+      class << self
+        attr_accessor :protocol, :position_encoding
+      end
+      @position_encoding = 'utf-16'
+
+      def self.collect(uri, content, shared_module_cache: nil, source_overrides: nil, workspace_root_path: nil, dependency_resolution_mode: :auto, platform_override: nil, sema_snapshot: nil, strict_current_root_diagnostics: false, lint_tier: :full)
+        total_start = perf_logging? ? monotonic_time : nil
+        diagnostics = []
+        sema_facts = nil
+        unresolved_import_paths = []
+        normalized_lint_tier = Linter.normalize_lint_tier(lint_tier)
+        parse_ms = 0.0
+        imports_ms = 0.0
+        sema_ms = 0.0
+        strict_root_ms = 0.0
+        lint_ms = 0.0
+        lint_profile = total_start ? Linter::Profile.new : nil
+        path = uri_to_path(uri)
+        resolution = DependencyResolution.resolve(path, mode: dependency_resolution_mode)
+        effective_platform = effective_platform_for_path(path, platform_override:)
+
+        # Parse
+        begin
+          parse_start = total_start ? monotonic_time : nil
+          ast = if path && File.file?(path)
+                  parse_result = Parser.parse_collecting_errors(content, path: uri)
+                  parse_result.errors.each { |error| diagnostics << format_error(error) }
+                  parse_result.ast
+                else
+                  Parser.parse(content, path: uri)
+                end
+          parse_ms = elapsed_ms(parse_start) if parse_start
+          return { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot } unless ast
+
+          if resolution.error_message
+            diagnostics << format_error(SemanticError.new(resolution.error_message, line: 1, column: 1))
+            return { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot }
+          end
+
+          conflict_error = root_platform_conflict_error(path, effective_platform)
+          if conflict_error
+            diagnostics << format_error(SemanticError.new(conflict_error.message, line: 1, column: 1))
+            return { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot }
+          end
+
+          imports_start = total_start ? monotonic_time : nil
+          imported_modules = resolve_imported_modules(
+            uri,
+            ast,
+            diagnostics,
+            resolution:,
+            effective_platform:,
+            shared_module_cache: shared_module_cache,
+            source_overrides: source_overrides,
+            workspace_root_path: workspace_root_path,
+            content: content,
+          )
+          imports_ms = elapsed_ms(imports_start) if imports_start
+          unresolved_import_paths = imported_modules.fetch(:unresolved_import_paths)
+          inferred_module_name = imported_modules[:module_name]
+
+          # Wrap AST with module name before sema so facts.module_name is non-nil.
+          unless ast.respond_to?(:module_name) && ast.module_name
+            mn_parts = inferred_module_name ? inferred_module_name.split('.') : []
+            ast = AST::SourceFile.new(
+              module_name: mn_parts.any? ? AST::QualifiedName.new(parts: mn_parts) : nil,
+              module_kind: ast.respond_to?(:module_kind) ? ast.module_kind : nil,
+              imports: ast.respond_to?(:imports) ? (ast.imports || []) : [],
+              directives: ast.respond_to?(:directives) ? (ast.directives || []) : [],
+              declarations: ast.respond_to?(:declarations) ? (ast.declarations || []) : [],
+              line: ast.respond_to?(:line) ? ast.line : 1,
+              node_ids: ast.respond_to?(:node_ids) ? ast.node_ids : {},
+            )
+          end
+
+          # Semantic analysis — collect errors from all functions, not just first.
+          begin
+            sema_start = total_start ? monotonic_time : nil
+            sema_snapshot ||= SemanticAnalyzer.tooling_snapshot(ast, imported_modules: imported_modules.fetch(:modules), path: path, allow_missing_imports: true)
+            sema_facts = sema_snapshot.facts
+            sema_snapshot.diagnostics.reject { |diagnostic| redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths) }
+                           .each { |diagnostic| diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema') }
+            sema_ms = elapsed_ms(sema_start) if sema_start
+          rescue StandardError => e
+            log_diagnostics_warning("Error collecting diagnostics: #{e.message}")
+          end
+
+          begin
+            if strict_current_root_diagnostics && normalized_lint_tier == :full
+              strict_root_start = total_start ? monotonic_time : nil
+              collect_strict_root_diagnostics(
+                path,
+                ast,
+                sema_facts,
+                diagnostics,
+                resolution:,
+                effective_platform:,
+                shared_module_cache:,
+                source_overrides:,
+                workspace_root_path:,
+              ).each do |diagnostic|
+                diagnostics << diagnostic
+              end
+              strict_root_ms = elapsed_ms(strict_root_start) if strict_root_start
+            end
+          rescue StandardError => e
+            log_diagnostics_warning("Error collecting strict root diagnostics: #{e.message}")
+          end
+        rescue MilkTea::LexError => e
+          diagnostics << format_error(e)
+        rescue StandardError => e
+          log_diagnostics_warning("Error collecting diagnostics: #{e.message}")
+        end
+
+        # Lint warnings (severity: 2 = Warning)
+        begin
+          lint_start = total_start ? monotonic_time : nil
+          Linter.lint_source(
+            content,
+            path: uri,
+            sema_facts: sema_facts,
+            unresolved_import_paths: unresolved_import_paths,
+            profile: lint_profile,
+            lint_tier: normalized_lint_tier,
+          ).each do |w|
+            diagnostics << format_warning(w, content: content)
+          end
+          lint_ms = elapsed_ms(lint_start) if lint_start
+        rescue MilkTea::LexError, MilkTea::ParseError
+          # Best-effort only while the user is mid-edit; lex/parse failures are
+          # already reported by the main diagnostics path.
+        rescue StandardError => e
+          log_diagnostics_warning("Error collecting lint diagnostics: #{e.message}")
+        end
+
+        { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot }
+      ensure
+        if total_start
+          lint_breakdown = lint_profile&.summary(limit: 12)
+          detail = "uri=#{uri} lint_tier=#{normalized_lint_tier} diagnostics=#{diagnostics.length} facts=#{sema_facts ? 'ok' : 'nil'} stages_ms=parse:#{parse_ms},imports:#{imports_ms},sema:#{sema_ms},strict_root:#{strict_root_ms},lint:#{lint_ms}"
+          detail += " lint_passes_ms=#{lint_breakdown}" unless lint_breakdown.nil? || lint_breakdown.empty?
+          log_perf_breakdown(
+            'diagnostics.collect',
+            elapsed_ms(total_start),
+            detail,
+          )
+        end
+      end
+
+      private
+
+      def self.resolve_imported_modules(uri, ast, diagnostics, resolution:, effective_platform:, shared_module_cache: nil, source_overrides: nil, workspace_root_path: nil, content: nil)
+        path = uri_to_path(uri)
+         return { modules: {}, unresolved_import_paths: [], module_name: nil } unless path && File.file?(path)
+
+        loader = ModuleLoader.new(
+          module_roots: module_roots_for_path(path, locked: resolution.locked, workspace_root_path: workspace_root_path),
+          package_graph: load_package_graph(path, locked: resolution.locked),
+          shared_cache: shared_module_cache,
+          source_overrides: source_overrides,
+          platform: effective_platform,
+        )
+        module_name = loader.send(:inferred_module_name_for_path, path) rescue nil
+        resolution_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
+        unresolved_import_paths = []
+
+        resolution_result.errors.each do |entry|
+          if entry.error.is_a?(ModuleLoadError)
+            diagnostics << format_import_error(entry.error, entry.import, content: content)
+            unresolved_import_paths << entry.import.path.to_s if entry.import
+          else
+            diagnostics << format_error(SemanticError.new(entry.error.message))
+          end
+        end
+
+        { modules: resolution_result.modules, unresolved_import_paths: unresolved_import_paths.uniq, module_name: module_name }
+      rescue ModuleLoadError, PackageLockError => e
+        if e.is_a?(ModuleLoadError)
+          import = ast.imports.find { |candidate| candidate.path.to_s == e.path }
+          diagnostics << format_import_error(e, import, content: content)
+        else
+          diagnostics << format_error(SemanticError.new(e.message))
+        end
+        { modules: {}, unresolved_import_paths: [], module_name: nil }
+      end
+
+      def self.redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths)
+        return false unless diagnostic&.message.to_s.start_with?("unknown import ")
+
+        unresolved_import_paths.include?(diagnostic.message.delete_prefix("unknown import "))
+      end
+
+      def self.uri_to_path(uri)
+        parsed = URI.parse(uri)
+        return nil unless parsed.scheme == "file"
+
+        CGI.unescape(parsed.path)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def self.perf_logging?
+        @perf_logging ||= !ENV.fetch('MILK_TEA_LSP_PERF', nil).to_s.empty?
+      end
+
+      def self.perf_verbose?
+        @perf_verbose ||= ENV.fetch('MILK_TEA_LSP_PERF', nil).to_s == 'verbose'
+      end
+
+      def self.perf_breakdown_logging?(elapsed_ms_value)
+        perf_logging? && (perf_verbose? || elapsed_ms_value > Workspace::PERF_LOG_THRESHOLD_MS)
+      end
+
+      def self.monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def self.elapsed_ms(start_time)
+        ((monotonic_time - start_time) * 1000).round(1)
+      end
+
+      def self.log_perf_breakdown(name, elapsed_ms_value, detail)
+        return unless perf_breakdown_logging?(elapsed_ms_value)
+
+        warn "[LSP perf] breakdown #{name} #{elapsed_ms_value}ms #{detail}"
+      end
+
+      def self.load_package_graph(path, locked: false)
+        @pkg_graph_cache ||= {}
+        cache_key = [path, locked]
+        return @pkg_graph_cache[cache_key] if @pkg_graph_cache.key?(cache_key)
+
+        @pkg_graph_cache[cache_key] = PackageGraph.load(path, locked:)
+      rescue PackageManifestError
+        @pkg_graph_cache[cache_key] = nil
+      end
+      private_class_method :load_package_graph
+
+      def self.effective_platform_for_path(path, platform_override: nil)
+        return nil unless path
+
+        ModuleLoader.effective_platform_for_path(path, platform_override:)
+      end
+      private_class_method :effective_platform_for_path
+
+      def self.root_platform_conflict_error(path, effective_platform)
+        return nil unless path && File.file?(path)
+        return nil unless ModuleLoader.platform_suffix_for_path(path)
+
+        ModuleLoader.resolve_source_path(path, platform: effective_platform, error_class: ModuleLoadError)
+        nil
+      rescue ModuleLoadError => e
+        e
+      end
+      private_class_method :root_platform_conflict_error
+
+      def self.collect_strict_root_diagnostics(path, ast, sema_facts, existing_diagnostics, resolution:, effective_platform:, shared_module_cache: nil, source_overrides: nil, workspace_root_path: nil)
+        return [] unless strict_root_check_eligible?(path, ast, sema_facts, existing_diagnostics)
+
+        loader = ModuleLoader.new(
+          module_roots: module_roots_for_path(path, locked: resolution.locked, workspace_root_path: workspace_root_path),
+          package_graph: load_package_graph(path, locked: resolution.locked),
+          shared_cache: shared_module_cache,
+          source_overrides: source_overrides,
+          platform: effective_platform,
+        )
+        program = loader.check_program(path)
+        Build.frontend_build_artifacts(program)
+        []
+      rescue ModuleLoadError, PackageLockError, SemanticError, LoweringError, BuildError => e
+        [format_strict_root_error(e, path: path)]
+      end
+      private_class_method :collect_strict_root_diagnostics
+
+      def self.strict_root_check_eligible?(path, ast, sema_facts, existing_diagnostics)
+        return false unless path && File.file?(path)
+        return false unless sema_facts
+        return false if ast&.module_kind == :external
+
+        existing_diagnostics.none? do |diagnostic|
+          diagnostic[:severity] == 1 && diagnostic.dig(:data, :stage) != 'lint'
+        end
+      end
+      private_class_method :strict_root_check_eligible?
+
+      def self.format_strict_root_error(error, path:)
+        diagnostic = Diagnostic.new(
+          path: path,
+          line: error.respond_to?(:line) && error.line ? error.line : 1,
+          column: error.respond_to?(:column) && error.column ? error.column : 1,
+          code: strict_root_diagnostic_code(error),
+          message: "strict current-root check failed: #{error.message}",
+          severity: :error,
+        )
+        format_tooling_diagnostic(diagnostic, stage: 'strict-root')
+      end
+      private_class_method :format_strict_root_error
+
+      def self.module_roots_for_path(path, locked:, workspace_root_path: nil)
+        roots = MilkTea::ModuleRoots.roots_for_path(path, locked: locked)
+        return roots unless workspace_root_applicable_for?(path, workspace_root_path)
+
+        [File.expand_path(workspace_root_path), *roots].uniq
+      end
+      private_class_method :module_roots_for_path
+
+      def self.workspace_root_applicable_for?(path, workspace_root_path)
+        return false if path.nil? || workspace_root_path.nil? || workspace_root_path.to_s.strip.empty?
+
+        expanded_root = File.expand_path(workspace_root_path)
+        return false unless File.directory?(expanded_root)
+
+        expanded_path = File.expand_path(path)
+        expanded_path == expanded_root || expanded_path.start_with?(expanded_root + File::SEPARATOR)
+      end
+      private_class_method :workspace_root_applicable_for?
+
+      def self.strict_root_diagnostic_code(error)
+        case error
+        when MilkTea::ModuleLoadError
+          'import/load-error'
+        when MilkTea::SemanticError
+          'sema/error'
+        when MilkTea::LoweringError
+          'lowering/error'
+        when MilkTea::BuildError
+          'build/error'
+        when MilkTea::PackageLockError
+          'package/lock-error'
+        else
+          'tooling/error'
+        end
+      end
+      private_class_method :strict_root_diagnostic_code
+
+      def self.format_warning(warning, content: nil)
+        format_tooling_diagnostic(warning.to_diagnostic, content:, stage: 'lint')
+      end
+
+      def self.format_tooling_diagnostic(diagnostic, content: nil, stage:)
+        line = diagnostic.line.to_i
+        line_index = [line - 1, 0].max
+        start_char, end_char = extract_warning_range(diagnostic, content)
+
+        lsp_severity = case diagnostic.severity
+                       when :error   then 1
+                       when :warning then 2
+                       when :info    then 3
+                       when :hint    then 4
+                       else               2
+                       end
+        {
+          range: {
+            start: { line: line_index, character: start_char },
+            end:   { line: line_index, character: end_char }
+          },
+          severity: lsp_severity,
+          code: diagnostic.code,
+          message: diagnostic_message_to_client(diagnostic.message.to_s, diagnostic.code),
+          source: 'milk-tea',
+          data: {
+            stage: stage
+          }
+        }
+      end
+
+      # Returns [start_char, end_char] in 0-based LSP coordinates.
+      # Falls back to [0, 1] when a precise token span cannot be inferred.
+      def self.extract_warning_range(warning, content)
+        if warning.respond_to?(:column) && warning.column
+          start_char = [warning.column.to_i - 1, 0].max
+          len = warning.respond_to?(:length) ? warning.length.to_i : 0
+          len = 1 if len <= 0
+          return [start_char, start_char + len]
+        end
+
+        return [0, 1] unless content && warning.line
+
+        lines = content.split("\n", -1)
+        line_text = lines[warning.line - 1]
+        return [0, 1] unless line_text
+
+        token_name = warning.respond_to?(:symbol_name) ? warning.symbol_name : nil
+        token_name ||= extract_quoted_name(warning.message.to_s)
+        return [0, 1] unless token_name && !token_name.empty?
+
+        # Prefer whole-token matches so names like "arg" don't match inside "argv".
+        token_match = line_text.match(/\b#{Regexp.escape(token_name)}\b/)
+        return [token_match.begin(0), token_match.end(0)] if token_match
+
+        # Fallback for non-word symbols if any rule introduces them.
+        index = line_text.index(token_name)
+        return [index, index + token_name.length] if index
+
+        [0, 1]
+      rescue StandardError
+        [0, 1]
+      end
+
+      def self.extract_quoted_name(message)
+        match = message.match(/'([^']+)'/)
+        match && match[1]
+      end
+
+      def self.format_error(error)
+        line = extract_line(error)
+        column = extract_column(error)
+        length = extract_length(error)
+        start_char = [column.to_i - 1, 0].max
+        end_char = start_char + [length.to_i, 1].max
+        code = diagnostic_code(error)
+
+        diagnostic = {
+          range: {
+            start: {
+              line: (line.to_i - 1),
+              character: start_char
+            },
+            end: {
+              line: (line.to_i - 1),
+              character: end_char
+            }
+          },
+          severity: 1,  # Error
+          code: code,
+          message: diagnostic_message_to_client(error.message.to_s, code),
+          source: 'milk-tea',
+          data: {
+            stage: diagnostic_stage(error)
+          }
+        }
+        if error.respond_to?(:suggestion) && error.suggestion
+          diagnostic[:data][:suggestion] = error.suggestion
+        end
+        diagnostic
+      end
+
+      def self.format_import_error(error, import, content: nil)
+        return format_error(SemanticError.new(error.message)) unless import
+
+        column, length = import_path_span(import, content)
+        line_index = [import.line.to_i - 1, 0].max
+        start_char = [column.to_i - 1, 0].max
+        end_char = start_char + [length.to_i, 1].max
+        code = diagnostic_code(error)
+
+        {
+          range: {
+            start: {
+              line: line_index,
+              character: start_char,
+            },
+            end: {
+              line: line_index,
+              character: end_char,
+            }
+          },
+          severity: 1,
+          code: code,
+          message: diagnostic_message_to_client(error.message.to_s, code),
+          source: 'milk-tea',
+          data: {
+            stage: diagnostic_stage(error)
+          }
+        }
+      end
+
+      def self.diagnostic_code(error)
+        case error
+        when MilkTea::LexError
+          'lex/error'
+        when MilkTea::ParseError
+          'parse/error'
+        when MilkTea::ModuleLoadError
+          'import/load-error'
+        when MilkTea::SemanticError
+          'sema/error'
+        else
+          'tooling/error'
+        end
+      end
+
+      def self.diagnostic_stage(error)
+        case error
+        when MilkTea::LexError
+          'lex'
+        when MilkTea::ParseError
+          'parse'
+        when MilkTea::ModuleLoadError
+          'import'
+        when MilkTea::SemanticError
+          'sema'
+        else
+          'tooling'
+        end
+      end
+
+      def self.import_path_span(import, content)
+        return [import.column || 1, import.length || 1] unless content && import.line
+
+        line_text = content.split("\n", -1)[import.line - 1]
+        return [import.column || 1, import.length || 1] unless line_text
+
+        path_text = import.path.to_s
+        index = line_text.index(path_text)
+        return [index + 1, path_text.length] if index
+
+        [import.column || 1, import.length || 1]
+      rescue StandardError
+        [import.column || 1, import.length || 1]
+      end
+
+      def self.extract_line(error)
+        case error
+        when MilkTea::LexError
+          error.line || 1
+        when MilkTea::ParseError
+          error.token&.line || 1
+        when MilkTea::SemanticError
+          error.line || 1
+        else
+          1
+        end
+      end
+
+      def self.extract_column(error)
+        case error
+        when MilkTea::LexError
+          error.column || 1
+        when MilkTea::ParseError
+          error.token&.column || 1
+        when MilkTea::SemanticError
+          error.column || 1
+        else
+          1
+        end
+      end
+
+      def self.extract_length(error)
+        case error
+        when MilkTea::ParseError
+          error.token&.lexeme.to_s.length
+        when MilkTea::SemanticError
+          error.length || 1
+        else
+          1
+        end
+      end
+
+      def self.log_diagnostics_warning(message)
+        return unless @protocol
+
+        @protocol.write_notification('window/logMessage', {
+          type: 2,
+          message: message,
+        })
+      rescue StandardError
+        nil
+      end
+
+      def self.diagnostic_message_to_client(message, code)
+        return message unless message.is_a?(String)
+
+        code_spans = []
+        if code.to_s.start_with?('sema')
+          message.scan(/`([^`]+)`/) { |m| code_spans << m[0] }
+          message.scan(/'([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)'/) { |m| code_spans << m[0] unless code_spans.include?(m[0]) }
+        end
+
+        return message if code_spans.empty?
+
+        markdown = message.gsub(/`([^`]+)`/, '`\1`')
+        { kind: 'markdown', value: markdown }
+      end
+
+      def self.client_char_to_internal(line_text, client_char)
+        return client_char if @position_encoding == 'utf-16'
+
+        case @position_encoding
+        when 'utf-8'
+          bytes_seen = 0
+          utf16_count = 0
+          line_text.each_char do |ch|
+            break if bytes_seen >= client_char
+            bytes_seen += ch.bytesize
+            utf16_count += ch.ord > 0xFFFF ? 2 : 1
+          end
+          utf16_count
+        when 'utf-32'
+          utf16_count = 0
+          line_text.each_char.with_index do |ch, idx|
+            break if idx >= client_char
+            utf16_count += ch.ord > 0xFFFF ? 2 : 1
+          end
+          utf16_count
+        else
+          client_char
+        end
+      end
+    end
+  end
+end