mt-lang 0.2.0

data/lib/milk_tea/lsp/server.rb

@@ -0,0 +1,415 @@
+# frozen_string_literal: true
+
+
+require 'cgi/escape'
+require 'digest'
+require 'pathname'
+require 'set'
+require 'thread'
+require 'timeout'
+require 'uri'
+
+
+require_relative "server/call_hierarchy"
+require_relative "server/code_actions"
+require_relative "server/code_lens"
+require_relative "server/debug_info"
+require_relative "server/completion"
+require_relative "server/configuration"
+require_relative "server/definition"
+require_relative "server/diagnostics_scheduling"
+require_relative "server/execute_command"
+require_relative "server/folding_range"
+require_relative "server/formatting"
+require_relative "server/hover"
+require_relative "server/inlay_hints"
+require_relative "server/lifecycle"
+require_relative "server/linked_editing_range"
+require_relative "server/on_type_formatting"
+require_relative "server/progress"
+require_relative "server/references"
+require_relative "server/rename"
+require_relative "server/selection_range"
+require_relative "server/semantic_tokens"
+require_relative "server/signature_help"
+require_relative "server/text_documents"
+require_relative "server/type_hierarchy"
+require_relative "server/utilities"
+
+module MilkTea
+  module LSP
+    # Main LSP server — JSON-RPC 2.0 message loop with full MVP feature set.
+    #
+    # Enhancements implemented:
+    #   1. Hover         — real type signature from semantic facts
+    #   2. Goto Def      — token-based definition site navigation
+    #   3. Incremental   — textDocumentSync: 2 with range-based edits
+    #   4. Multi-file    — workspace indexing via workspace/symbol
+    #   5. Completion    — function/type/value completions from facts
+    class Server
+      SEMANTIC_TOKEN_TYPES = %w[
+        namespace type class enum interface struct typeParameter parameter variable property enumMember event
+        function method macro keyword modifier comment string number regexp operator decorator
+      ].freeze
+      SEMANTIC_TOKEN_MODIFIERS = %w[
+        declaration definition readonly static deprecated abstract async modification documentation defaultLibrary
+      ].freeze
+
+      KEYWORD_TOKEN_TYPES = Token::KEYWORDS.values.to_set.freeze
+      DEFAULT_LIBRARY_TYPE_NAMES = Types::BUILTIN_TYPE_NAMES.to_set.freeze
+      BUILTIN_FUNCTION_NAMES = %w[
+        ref_of const_ptr_of ptr_of read fatal reinterpret array span zero default adapt get
+      ].to_set.freeze
+      BUILTIN_ASSOCIATED_HOOK_NAMES = %w[hash equal order].to_set.freeze
+      BUILTIN_CALL_HOVER_INFO = {
+        'fatal' => {
+          signature: 'builtin fatal(message) -> never',
+          docs: '`fatal(message)` aborts execution with the provided message.'
+        },
+        'ref_of' => {
+          signature: 'builtin ref_of(value) -> ref[T]',
+          docs: '`ref_of(x)` borrows a mutable safe lvalue as `ref[T]`.'
+        },
+        'const_ptr_of' => {
+          signature: 'builtin const_ptr_of(value) -> const_ptr[T]',
+          docs: '`const_ptr_of(x)` takes the address of a safe lvalue as `const_ptr[T]`.'
+        },
+        'ptr_of' => {
+          signature: 'builtin ptr_of(value) -> ptr[T]',
+          docs: '`ptr_of(x)` takes the address of a mutable safe lvalue as `ptr[T]`.'
+        },
+        'read' => {
+          signature: 'builtin read(value) -> T',
+          docs: '`read(value)` projects a `ref[T]` or pointer-like value to its referent.'
+        },
+        'adapt' => {
+          signature: 'builtin adapt[Interface](value) -> dyn[Interface]',
+          docs: '`adapt[Interface](value)` constructs a `dyn[Interface]` runtime interface value. Compile-time verified: the value\'s type must implement the interface.'
+        },
+        'reinterpret' => {
+          signature: 'builtin reinterpret[T](value) -> T',
+          docs: '`reinterpret[T](value)` reinterprets the bits of `value` as type `T` without conversion. Requires `unsafe`.'
+        },
+        'array' => {
+          signature: 'builtin array[T, N](elements...) -> array[T, N]',
+          docs: '`array[T, N]` constructs a fixed-size array from elements. Omitted trailing elements default to zero.'
+        },
+        'span' => {
+          signature: 'builtin span[T](data, len) -> span[T]',
+          docs: '`span[T](data = ..., len = ...)` constructs a borrowed pointer-plus-length view over contiguous memory.'
+        },
+        'zero' => {
+          signature: 'builtin zero[T] -> T',
+          docs: '`zero[T]` returns a zero-initialized value of type `T`. All bits are set to zero.'
+        },
+        'default' => {
+          signature: 'builtin default[T] -> T',
+          docs: '`default[T]` calls `T.default()` to produce a semantic default value. Requires an accessible `default()` associated function on `T`.'
+        },
+        'get' => {
+          signature: 'builtin get(collection, index) -> ptr[T]?',
+          docs: '`get(collection, index)` performs recoverable bounds-checked indexing, returning `ptr[T]?` (null on out-of-bounds) instead of aborting.'
+        },
+        'attribute_arg' => {
+          signature: 'builtin attribute_arg[T](handle) -> T',
+          docs: '`attribute_arg[T](handle)` returns the `T`-typed argument of a resolved `attribute_handle`. The attribute must declare an argument of type `T`.'
+        },
+        'field_of' => {
+          signature: 'builtin field_of(Type, field_name) -> field_handle',
+          docs: '`field_of(Type, field_name)` returns a compile-time handle for the named field on a struct type.'
+        },
+        'callable_of' => {
+          signature: 'builtin callable_of(name) -> callable_handle',
+          docs: '`callable_of(name)` returns a compile-time handle for a callable declaration name.'
+        },
+        'has_attribute' => {
+          signature: 'builtin has_attribute(target, attribute_name) -> bool',
+          docs: '`has_attribute(target, attribute_name)` checks at compile time whether the resolved attribute is applied to the target.'
+        },
+        'attribute_of' => {
+          signature: 'builtin attribute_of(target, attribute_name) -> attribute_handle',
+          docs: '`attribute_of(target, attribute_name)` returns the applied attribute handle for the resolved target-and-attribute pair; use `has_attribute(...)` when absence is expected.'
+        },
+      }.freeze
+      OPERATOR_TOKEN_TYPES = %i[
+        amp colon comma caret dot lparen rparen pipe lbracket rbracket question
+        equal plus minus star slash percent less greater tilde
+        arrow shift_left shift_right plus_equal minus_equal star_equal slash_equal percent_equal
+        amp_equal pipe_equal caret_equal shift_left_equal shift_right_equal
+        equal_equal bang_equal less_equal greater_equal ellipsis
+        at dot_dot
+      ].to_set.freeze
+      DIAGNOSTICS_WORKER_COUNT = Integer(ENV.fetch('MILK_TEA_LSP_DIAGNOSTICS_WORKERS', '2')).clamp(1, 8)
+
+      def self.semantic_tokens_for_path(path, module_roots: nil, package_graph: nil)
+        expanded_path = File.expand_path(path)
+        roots = module_roots || MilkTea::ModuleRoots.roots_for_path(expanded_path)
+        source = File.read(expanded_path)
+        tokens = MilkTea::Lexer.lex(source, path: expanded_path)
+        facts = MilkTea::ModuleLoader.new(
+          module_roots: roots,
+          package_graph: package_graph || load_package_graph(expanded_path),
+        ).check_file(expanded_path)
+
+        helper = allocate
+        entries = helper.send(:build_semantic_token_entries, tokens, facts)
+        data = helper.send(:encode_semantic_tokens, entries)
+
+        {
+          path: expanded_path,
+          moduleName: facts.module_name,
+          legend: {
+            tokenTypes: SEMANTIC_TOKEN_TYPES,
+            tokenModifiers: SEMANTIC_TOKEN_MODIFIERS,
+          },
+          data: data,
+          entries: entries.map do |entry|
+            {
+              line: entry[:line],
+              startChar: entry[:start_char],
+              length: entry[:length],
+              tokenType: entry[:type].to_s,
+              modifiers: entry[:modifiers].map(&:to_s),
+            }
+          end,
+        }
+      end
+
+      def self.load_package_graph(path, locked: false)
+        PackageGraph.load(path, locked:)
+      rescue PackageManifestError
+        nil
+      end
+      private_class_method :load_package_graph
+
+      def initialize(protocol: Protocol)
+        @protocol = protocol
+        @workspace = Workspace.new
+        @format_mode = :tidy
+        @dependency_resolution_mode = :auto
+        @platform_override = nil
+        @position_encoding = 'utf-16'
+        @handlers = {}
+        @diagnostic_report_cache = {}
+        @workspace_diagnostic_cache = {}
+        @semantic_tokens_cache = {}
+        @semantic_tokens_delta_cache = {}
+        @fixall_cache = {}
+        @definition_file_token_cache = {}
+        @definition_file_ast_cache = {}
+        @diagnostics_perf = {
+          scheduled: 0,
+          skipped_unchanged: 0,
+          cancelled: 0,
+          dequeued: 0,
+          collected_for_pull: 0,
+          published: 0,
+          dropped_stale: 0,
+          requeued: 0,
+          queue_peak: 0,
+        }
+        @diagnostics_mutex = Mutex.new
+        @diagnostics_pending = {}
+        @diagnostics_enqueued = Set.new
+        @diagnostics_generation = Hash.new(0)
+        @diagnostics_last_scheduled_hash = {}
+        @diagnostics_queue = Queue.new
+        @diagnostics_workers = []
+        @cancelled_requests_mutex = Mutex.new
+        @cancelled_request_ids = Set.new
+        @_initialize_called = false
+        @_indexing_thread = nil
+        Diagnostics.protocol = @protocol
+        Diagnostics.position_encoding = @position_encoding
+        register_handlers
+        start_diagnostics_workers
+      end
+
+      def run
+        if perf_logging?
+          mode = perf_verbose? ? 'verbose' : 'threshold'
+          warn "[LSP perf] enabled mode=#{mode} threshold_ms=#{Workspace::PERF_LOG_THRESHOLD_MS}"
+        end
+
+        loop do
+          message = @protocol.read_message
+          break if message.nil?
+          next if message.equal?(Protocol::INVALID_MESSAGE)
+
+          process_message(message)
+        end
+      rescue StandardError => e
+        warn "Server error: #{e.message}"
+        raise
+      end
+
+
+      private
+
+      include ServerCallHierarchy
+      include ServerCodeActions
+      include ServerCodeLens
+      include ServerDebugInfo
+      include ServerCompletion
+      include ServerConfiguration
+      include ServerDefinition
+      include ServerDiagnosticsScheduling
+      include ServerFoldingRange
+      include ServerFormatting
+      include ServerHover
+      include ServerInlayHints
+      include ServerLifecycle
+      include ServerOnTypeFormatting
+      include ServerProgress
+      include ServerReferences
+      include ServerExecuteCommand
+      include ServerLinkedEditingRange
+      include ServerRename
+      include ServerSelectionRange
+      include ServerSemanticTokens
+      include ServerSignatureHelp
+      include ServerTextDocuments
+      include ServerTypeHierarchy
+      include ServerUtilities
+
+      # ── Handler registration ─────────────────────────────────────────────────
+
+      def register_handlers
+        # Lifecycle
+        @handlers['initialize']  = method(:handle_initialize)
+        @handlers['initialized'] = method(:handle_initialized)
+        @handlers['shutdown']    = method(:handle_shutdown)
+        @handlers['exit']        = method(:handle_exit)
+        @handlers['$/cancelRequest'] = method(:handle_cancel_request)
+
+        # Text document sync
+        @handlers['milkTea/documentContext'] = method(:handle_document_context)
+        @handlers['textDocument/didOpen']   = method(:handle_did_open)
+        @handlers['textDocument/didChange'] = method(:handle_did_change)
+        @handlers['textDocument/didClose']  = method(:handle_did_close)
+        @handlers['textDocument/didSave']   = method(:handle_did_save)
+        @handlers['textDocument/willSaveWaitUntil'] = method(:handle_will_save_wait_until)
+
+        # IDE features
+        @handlers['textDocument/hover']             = method(:handle_hover)
+        @handlers['textDocument/definition']        = method(:handle_definition)
+        @handlers['textDocument/declaration']       = method(:handle_declaration)
+        @handlers['textDocument/typeDefinition']    = method(:handle_type_definition)
+        @handlers['textDocument/implementation']    = method(:handle_implementation)
+        @handlers['textDocument/references']        = method(:handle_references)
+        @handlers['milkTea/debugInfo']             = method(:handle_debug_info)
+        @handlers['textDocument/documentLink']      = method(:handle_document_link)
+        @handlers['documentLink/resolve']           = method(:handle_document_link_resolve)
+        @handlers['textDocument/documentHighlight'] = method(:handle_document_highlight)
+        @handlers['textDocument/documentSymbol']    = method(:handle_document_symbols)
+        @handlers['textDocument/formatting']        = method(:handle_formatting)
+        @handlers['textDocument/rangeFormatting']   = method(:handle_range_formatting)
+        @handlers['textDocument/onTypeFormatting']   = method(:handle_on_type_formatting)
+        @handlers['textDocument/foldingRange']       = method(:handle_folding_range)
+        @handlers['textDocument/completion']        = method(:handle_completion)
+        @handlers['completionItem/resolve']         = method(:handle_completion_resolve)
+        @handlers['textDocument/codeAction']        = method(:handle_code_action)
+        @handlers['textDocument/codeLens']           = method(:handle_code_lens)
+        @handlers['codeLens/resolve']                 = method(:handle_code_lens_resolve)
+        @handlers['textDocument/prepareCallHierarchy'] = method(:handle_prepare_call_hierarchy)
+        @handlers['callHierarchy/incomingCalls']     = method(:handle_incoming_calls)
+        @handlers['callHierarchy/outgoingCalls']     = method(:handle_outgoing_calls)
+        @handlers['textDocument/inlayHint']         = method(:handle_inlay_hint)
+        @handlers['textDocument/semanticTokens/full'] = method(:handle_semantic_tokens_full)
+        @handlers['textDocument/semanticTokens/full/delta'] = method(:handle_semantic_tokens_delta)
+        @handlers['textDocument/semanticTokens/range'] = method(:handle_semantic_tokens_range)
+        @handlers['textDocument/selectionRange']     = method(:handle_selection_range)
+        @handlers['textDocument/diagnostic']         = method(:handle_document_diagnostic)
+        @handlers['workspace/diagnostic']            = method(:handle_workspace_diagnostic)
+        @handlers['textDocument/signatureHelp']     = method(:handle_signature_help)
+        @handlers['textDocument/prepareTypeHierarchy'] = method(:handle_prepare_type_hierarchy)
+        @handlers['typeHierarchy/supertypes']        = method(:handle_supertypes)
+        @handlers['typeHierarchy/subtypes']          = method(:handle_subtypes)
+        @handlers['textDocument/prepareRename']     = method(:handle_prepare_rename)
+        @handlers['textDocument/rename']            = method(:handle_rename)
+        @handlers['textDocument/linkedEditingRange'] = method(:handle_linked_editing_range)
+
+        # Workspace
+        @handlers['workspace/symbol'] = method(:handle_workspace_symbol)
+        @handlers['workspace/executeCommand'] = method(:handle_execute_command)
+        @handlers['workspace/didChangeWorkspaceFolders'] = method(:handle_did_change_workspace_folders)
+        @handlers['workspace/didChangeConfiguration'] = method(:handle_did_change_configuration)
+        @handlers['workspace/didChangeWatchedFiles'] = method(:handle_did_change_watched_files)
+        @handlers['workspace/willRenameFiles'] = method(:handle_will_rename_files)
+      end
+
+      # ── Message dispatch ─────────────────────────────────────────────────────
+
+      def process_message(message)
+        method_name = message['method']
+        params = message['params'] || {}
+        id     = message['id']
+
+        if message.key?('id') && !message.key?('method')
+          Protocol.handle_response(message)
+        elsif message.key?('id')
+          handle_request(method_name, params, id)
+        else
+          handle_notification(method_name, params)
+        end
+      rescue StandardError => e
+        log_message(:warning, "Error processing message: #{e.message}")
+        @protocol.write_error(id, -32_603, 'Internal server error') if id && message.key?('method')
+      end
+
+      def handle_request(method_name, params, id)
+        if request_cancelled?(id)
+          clear_cancelled_request(id)
+          @protocol.write_error(id, -32_800, 'Request cancelled')
+          return
+        end
+
+        handler = @handlers[method_name]
+        if handler.nil?
+          @protocol.write_error(id, -32_601, 'Method not found')
+          return
+        end
+
+        begin
+          @current_request_id = id
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = handler.call(params)
+          elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(1)
+          if perf_logging? && (perf_verbose? || elapsed_ms > Workspace::PERF_LOG_THRESHOLD_MS)
+            detail = perf_log_context(method_name, params, verbose: perf_verbose?)
+            warn "[LSP perf] req #{method_name} #{elapsed_ms}ms id=#{id}#{detail}"
+          end
+          if request_cancelled?(id)
+            clear_cancelled_request(id)
+            @protocol.write_error(id, -32_800, 'Request cancelled')
+          else
+            @protocol.write_response(id, result)
+          end
+        rescue StandardError => e
+          log_message(:warning, "Error in handler for #{method_name}: #{e.message}")
+          @protocol.write_error(id, -32_603, "Internal error: #{e.message}")
+        ensure
+          clear_cancelled_request(id)
+          @current_request_id = nil
+        end
+      end
+
+      def handle_notification(method_name, params)
+        handler = @handlers[method_name]
+        return unless handler
+
+        begin
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          handler.call(params)
+          elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(1)
+          if perf_logging? && (perf_verbose? || elapsed_ms > Workspace::PERF_LOG_THRESHOLD_MS)
+            detail = perf_log_context(method_name, params, verbose: perf_verbose?)
+            warn "[LSP perf] ntf #{method_name} #{elapsed_ms}ms#{detail}"
+          end
+        rescue StandardError => e
+          log_message(:warning, "Error in notification handler for #{method_name}: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/lsp/workspace/analysis.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class Workspace
+      module WorkspaceAnalysis
+        private
+
+        # ── Compilation helpers ─────────────────────────────────────────────────
+
+        def lex_document(uri)
+          content = get_content(uri)
+          return nil if content.empty?
+
+          recovery_errors = []
+          tokens = MilkTea::Lexer.lex(content, path: uri, recovery_errors:)
+          @last_good_tokens_cache[uri] = tokens
+          index_identifier_tokens(uri, tokens) if tokens
+          tokens
+        rescue StandardError
+          @last_good_tokens_cache[uri] || @tokens_cache[uri]
+        end
+
+        def parse_document(uri)
+          tokens = get_tokens(uri)
+          return nil if tokens.nil?
+
+          MilkTea::Parser.parse_collecting_errors(tokens: tokens, path: uri).ast
+        rescue StandardError
+          nil
+        end
+
+        def perf_logging?
+          @perf_logging ||= !ENV.fetch('MILK_TEA_LSP_PERF', nil).to_s.empty?
+        end
+
+        def perf_verbose?
+          @perf_verbose ||= ENV.fetch('MILK_TEA_LSP_PERF', nil).to_s == 'verbose'
+        end
+
+        def perf_breakdown_logging?(elapsed_ms_value)
+          perf_logging? && (perf_verbose? || elapsed_ms_value > PERF_LOG_THRESHOLD_MS)
+        end
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def elapsed_ms(start_time)
+          ((monotonic_time - start_time) * 1000).round(1)
+        end
+
+        def 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 ast_for_content(uri, content)
+          return get_ast(uri) if get_content(uri) == content
+
+          MilkTea::Parser.parse(content, path: uri)
+        rescue StandardError
+          nil
+        end
+
+        def warm_document_facts(uri, content)
+          ast = ast_for_content(uri, content)
+          stats = {
+            bytes: content.bytesize,
+            lines: content.count("\n") + 1,
+            eager_facts: false,
+            facts_mode: nil,
+            facts_ms: nil,
+            skip_reason: nil,
+            import_count: ast.respond_to?(:imports) ? ast.imports.length : 0,
+            shared_module_cache_size: @shared_module_cache.length,
+          }
+
+          if background_document?(uri)
+            stats[:skip_reason] = :background_document
+            return stats
+          end
+
+          facts_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          facts_path = uri_to_path(uri)
+          get_facts(uri)
+          stats[:eager_facts] = true
+          stats[:facts_mode] = facts_path && File.file?(facts_path) ? :module_loader : :memory
+          stats[:facts_ms] = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - facts_start) * 1000).round(1)
+          stats[:shared_module_cache_size] = @shared_module_cache.length
+          stats
+        end
+
+        def compute_facts_for_content(uri, content)
+          path = uri_to_path(uri)
+          if path && File.file?(path)
+            parse_result = MilkTea::Parser.parse_collecting_errors(content, path: uri)
+            ast = parse_result.ast
+            return nil unless ast
+
+            effective_platform = effective_platform_for_path(path)
+            ensure_root_platform_compatible!(path, effective_platform)
+            loader = MilkTea::ModuleLoader.new(
+              module_roots: module_roots_for_path(path),
+              package_graph: package_graph_for_path(path),
+              shared_cache: @shared_module_cache,
+              source_overrides: file_backed_source_overrides,
+              platform: effective_platform,
+            )
+            ast = with_inferred_module_name(ast, loader:, path:)
+            import_resolution = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
+            MilkTea::SemanticAnalyzer.tooling_snapshot(
+              ast,
+              imported_modules: import_resolution.modules,
+              allow_missing_imports: true,
+              path: path,
+            ).facts
+          else
+            ast = MilkTea::Parser.parse(content, path: uri)
+            MilkTea::SemanticAnalyzer.check(ast)
+          end
+        rescue MilkTea::LexError, MilkTea::SemanticError, ModuleLoadError
+          nil
+        end
+
+          def analyze_document(uri)
+            path = uri_to_path(uri)
+            snapshot = if path && File.file?(path)
+                         parse_result = MilkTea::Parser.parse_collecting_errors(get_content(uri), path: uri)
+                         ast = parse_result.ast
+                         return @last_good_tooling_snapshot_cache[uri] if ast.nil?
+
+                         @ast_cache[uri] = ast
+
+                         resolution = DependencyResolution.resolve(path, mode: @dependency_resolution_mode)
+                         return nil unless resolution.ok?
+
+                         effective_platform = effective_platform_for_path(path)
+                         ensure_root_platform_compatible!(path, effective_platform)
+
+                         loader = MilkTea::ModuleLoader.new(
+                           module_roots: module_roots_for_path(path, locked: resolution.locked),
+                           package_graph: package_graph_for_path(path, locked: resolution.locked),
+                           shared_cache: @shared_module_cache,
+                           source_overrides: file_backed_source_overrides,
+                           platform: effective_platform,
+                         )
+                         ast = with_inferred_module_name(ast, loader:, path:)
+                         import_resolution = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
+                         MilkTea::SemanticAnalyzer.tooling_snapshot(
+                           ast,
+                           imported_modules: import_resolution.modules,
+                           allow_missing_imports: true,
+                           path: path,
+                         )
+                        else
+                          ast = get_ast(uri)
+                          return @last_good_tooling_snapshot_cache[uri] if ast.nil?
+
+                          result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast)
+                          facts = result[:analysis]
+                          MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path: uri) } || []).freeze)
+                        end
+              if snapshot&.facts
+                @last_good_tooling_snapshot_cache[uri] = snapshot
+                @last_good_facts_cache[uri] = snapshot.facts
+                @document_module_names[uri] = snapshot.facts.module_name
+              end
+            snapshot
+          rescue MilkTea::LexError, MilkTea::SemanticError, ModuleLoadError, PackageLockError
+            @last_good_tooling_snapshot_cache[uri]
+          rescue StandardError => e
+            warn "LSP sema error #{uri}: #{e.message}"
+            @last_good_tooling_snapshot_cache[uri]
+          end
+
+        def package_graph_for_path(path, locked: false)
+          PackageGraph.load(path, locked:)
+        rescue PackageManifestError
+          nil
+        end
+
+        def with_inferred_module_name(ast, loader:, path:)
+          inferred_module_name = loader.send(:inferred_module_name_for_path, path)
+          AST::SourceFile.new(
+            module_name: AST::QualifiedName.new(inferred_module_name.split('.')),
+            module_kind: ast.module_kind,
+            imports: ast.imports,
+            directives: ast.directives,
+            declarations: ast.declarations,
+            line: ast.line,
+            node_ids: ast.node_ids,
+          )
+        end
+
+        def effective_platform_for_path(path)
+          ModuleLoader.effective_platform_for_path(path, platform_override: @platform_override)
+        end
+
+        def ensure_root_platform_compatible!(path, effective_platform)
+          return unless ModuleLoader.platform_suffix_for_path(path)
+
+          ModuleLoader.resolve_source_path(path, platform: effective_platform, error_class: ModuleLoadError)
+        end
+      end
+    end
+  end
+end