ruby-lsp 0.23.14 → 0.23.15

data/lib/ruby_lsp/listeners/hover.rb

@@ -299,7 +299,7 @@ module RubyLsp
         methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
-        first_method = T.must(methods.first)
+        first_method = methods.first #: as !nil
 
         title = "#{message}#{first_method.decorated_parameters}"
         title << first_method.formatted_signatures
@@ -365,7 +365,7 @@ module RubyLsp
 
         # We should only show hover for private constants if the constant is defined in the same namespace as the
         # reference
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
         return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{name}"
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -67,12 +67,18 @@ module RubyLsp
         return if special_method?(message)
 
         if Requests::Support::Sorbet.annotation?(node)
-          @response_builder.add_token(T.must(node.message_loc), :type)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :type,
+          )
         elsif !node.receiver && !node.opening_loc
           # If the node has a receiver, then the syntax is not ambiguous and semantic highlighting is not necessary to
           # determine that the token is a method call. The only ambiguous case is method calls with implicit self
           # receiver and no parenthesis, which may be confused with local variables
-          @response_builder.add_token(T.must(node.message_loc), :method)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :method,
+          )
         end
       end
 
@@ -98,7 +104,7 @@ module RubyLsp
 
       #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
       #: (Prism::BlockNode node) -> void
@@ -108,7 +114,7 @@ module RubyLsp
 
       #: (Prism::BlockNode node) -> void
       def on_block_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
       #: (Prism::BlockLocalVariableNode node) -> void
@@ -301,7 +307,8 @@ module RubyLsp
         # For each capture name we find in the regexp, look for a local in the current_scope
         Regexp.new(content, Regexp::FIXEDENCODING).names.each do |name|
           # The +3 is to compensate for the "(?<" part of the capture name
-          capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
+          capture_name_index = content.index("(?<#{name}>") #: as !nil
+          capture_name_offset = capture_name_index + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
           local = @current_scope.lookup(name)

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -69,7 +69,11 @@ module RubyLsp
           signature.matches?(arguments)
         end || 0
 
-        parameter_length = [T.must(signatures[active_sig_index]).parameters.length - 1, 0].max
+        parameter_length = [
+          signatures[active_sig_index] #: as !nil
+            .parameters.length - 1,
+          0,
+        ].max
         active_parameter = (arguments.length - 1).clamp(0, parameter_length)
 
         # If there are arguments, then we need to check if there's a trailing comma after the end of the last argument

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -148,7 +148,7 @@ module RubyLsp
       def in_spec_context?
         return true if @nesting.empty?
 
-        T.must(@spec_class_stack.last)
+        @spec_class_stack.last #: as !nil
       end
     end
   end

data/lib/ruby_lsp/listeners/test_style.rb

@@ -22,7 +22,7 @@ module RubyLsp
           queue = items.dup
 
           until queue.empty?
-            item = T.must(queue.shift)
+            item = queue.shift #: as !nil
             tags = Set.new(item[:tags])
             next unless tags.include?("framework:minitest") || tags.include?("framework:test_unit")
 
@@ -133,8 +133,8 @@ module RubyLsp
 
       include Requests::Support::Common
 
-      MINITEST_REPORTER_PATH = File.expand_path("../ruby_lsp_reporter_plugin.rb", __dir__) #: String
-      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_unit_test_runner.rb", __dir__) #: String
+      MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
+      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
       ACCESS_MODIFIERS = [:public, :private, :protected].freeze
       BASE_COMMAND = begin
         Bundler.with_original_env { Bundler.default_lockfile }

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -97,7 +97,7 @@ module RubyLsp
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
@@ -153,7 +153,8 @@ module RubyLsp
           indentation_line = lines[indentation_line_number]
           return Error::InvalidTargetRange unless indentation_line
 
-          indentation = T.must(indentation_line[/\A */]).size
+          indentation = indentation_line[/\A */] #: as !nil
+            .size
 
           target_range = {
             start: { line: target_line, character: indentation },
@@ -195,7 +196,7 @@ module RubyLsp
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -54,7 +54,7 @@ module RubyLsp
           end
         end
 
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
           label = +"#{label}#{first_entry.decorated_parameters}"

data/lib/ruby_lsp/requests/hover.rb

@@ -37,8 +37,8 @@ module RubyLsp
 
         if should_refine_target?(parent, target)
           target = determine_target(
-            T.must(target),
-            T.must(parent),
+            target, #: as !nil
+            parent, #: as !nil
             position,
           )
         elsif position_outside_target?(position, target)

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -51,7 +51,9 @@ module RubyLsp
           # But if it's a RBS signature starting with `#:`, we'll ignore it
           # so users can immediately continue typing the method definition
           if (comment_match = @previous_line.match(/^#(?!:)(\s*)/))
-            handle_comment_line(T.must(comment_match[1]))
+            handle_comment_line(
+              comment_match[1], #: as !nil
+            )
           elsif @document.syntax_error?
             match = /(<<((-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
             heredoc_delimiter = match && match.named_captures["delimiter"]
@@ -76,7 +78,7 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         return unless /((?<=do)|(?<={))\s+\|/.match?(current_line)
 
-        line = T.must(current_line)
+        line = current_line #: as !nil
 
         # If the user inserts the closing pipe manually to the end of the block argument, we need to avoid adding
         # an additional one and remove the previous one.  This also helps to remove the user who accidentally

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -49,8 +49,7 @@ module RubyLsp
 
         # While the spec allows for multiple entries, VSCode seems to only support one
         # We'll just return the first one for now
-        first_entry = T.must(entries.first)
-
+        first_entry = entries.first #: as !nil
         range = range_from_location(first_entry.location)
 
         [

data/lib/ruby_lsp/requests/references.rb

@@ -106,7 +106,8 @@ module RubyLsp
           entries = @global_state.index.resolve(name, node_context.nesting)
           return unless entries
 
-          fully_qualified_name = T.must(entries.first).name
+          fully_qualified_name = entries.first #: as !nil
+            .name
           RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         when
           Prism::InstanceVariableAndWriteNode,

data/lib/ruby_lsp/requests/rename.rb

@@ -63,10 +63,11 @@ module RubyLsp
         return unless entries
 
         if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
-          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+          raise InvalidNameError, "The new name is already in use by #{conflict_entries.first&.name}"
         end
 
-        fully_qualified_name = T.must(entries.first).name
+        fully_qualified_name = entries.first #: as !nil
+          .name
         reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         changes = collect_text_edits(reference_target, name)
 
@@ -97,9 +98,9 @@ module RubyLsp
         # rename the files for the user.
         #
         # We also look for an associated test file and rename it too
-        short_name = T.must(fully_qualified_name.split("::").last)
+        short_name = fully_qualified_name.split("::").last #: as !nil
 
-        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+        @global_state.index[fully_qualified_name]&.each do |entry|
           # Do not rename files that are not part of the workspace
           uri = entry.uri
           file_path = uri.full_path
@@ -112,7 +113,9 @@ module RubyLsp
             file_name = file_from_constant_name(short_name)
 
             if "#{file_name}.rb" == entry.file_name
-              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+              new_file_name = file_from_constant_name(
+                @new_name.split("::").last, #: as !nil
+              )
 
               new_uri = URI::Generic.from_path(path: File.join(
                 File.dirname(file_path),

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -43,8 +43,8 @@ module RubyLsp
           # Filter the tokens based on the first different position. This must happen at this stage, before we try to
           # find the next position from the end or else we risk confusing sets of token that may have different lengths,
           # but end with the exact same token
-          old_tokens = T.must(previous_tokens[first_different_position...])
-          new_tokens = T.must(current_tokens[first_different_position...])
+          old_tokens = previous_tokens[first_different_position...] #: as !nil
+          new_tokens = current_tokens[first_different_position...] #: as !nil
 
           # Then search from the end to find the first token that doesn't match. Since the user is normally editing the
           # middle of the file, this will minimize the number of edits since the end of the token array has not changed
@@ -53,8 +53,8 @@ module RubyLsp
           end || 0
 
           # Filter the old and new tokens to only the section that will be replaced/inserted/deleted
-          old_tokens = T.must(old_tokens[...old_tokens.length - first_different_token_from_end])
-          new_tokens = T.must(new_tokens[...new_tokens.length - first_different_token_from_end])
+          old_tokens = old_tokens[...old_tokens.length - first_different_token_from_end] #: as !nil
+          new_tokens = new_tokens[...new_tokens.length - first_different_token_from_end] #: as !nil
 
           # And we send back a single edit, replacing an entire section for the new tokens
           Interface::SemanticTokensDelta.new(

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -29,7 +29,7 @@ module RubyLsp
 
       #: -> String
       def ast_for_range
-        range = T.must(@range)
+        range = @range #: as !nil
         start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup

data/lib/ruby_lsp/requests/support/common.rb

@@ -54,7 +54,9 @@ module RubyLsp
         #: (String file_path) -> bool?
         def not_in_dependencies?(file_path)
           BUNDLE_PATH &&
-            !file_path.start_with?(T.must(BUNDLE_PATH)) &&
+            !file_path.start_with?(
+              BUNDLE_PATH, #: as !nil
+            ) &&
             !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
 

data/lib/ruby_lsp/requests/support/rubocop_formatter.rb

@@ -21,7 +21,7 @@ module RubyLsp
         # @override
         #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
 
           # Invoke RuboCop with just this file in `paths`
           @format_runner.run(filename, document.source)
@@ -38,7 +38,7 @@ module RubyLsp
         # @override
         #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
           # Invoke RuboCop with just this file in `paths`
           @diagnostic_runner.run(filename, document.source)
 

data/lib/ruby_lsp/requests/support/source_uri.rb

@@ -71,7 +71,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = @@schemes # rubocop:disable Style/ClassVars #: Hash[String, untyped]
+      @@schemes = @@schemes #: Hash[String, untyped] # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -38,13 +38,14 @@ module RubyLsp
 
       #: -> (SymbolHierarchyRoot | Interface::DocumentSymbol)
       def last
-        T.must(@stack.last)
+        @stack.last #: as !nil
       end
 
       # @override
       #: -> Array[Interface::DocumentSymbol]
       def response
-        T.must(@stack.first).children
+        @stack.first #: as !nil
+          .children
       end
     end
   end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -35,7 +35,7 @@ module RubyLsp
       # @override
       #: -> ResponseType
       def response
-        result = T.must(@response[:title])
+        result = @response[:title] #: as !nil
         result << "\n" << @response[:links] if @response[:links]
         result << "\n" << @response[:documentation] if @response[:documentation]
 

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -64,7 +64,7 @@ module RubyLsp
             start_line: location.start_line,
             start_code_unit_column: location.cached_start_code_units_column(@code_units_cache),
             length: length,
-            type: T.must(TOKEN_TYPES[type]),
+            type: TOKEN_TYPES[type], #: as !nil
             modifier: modifiers_indices,
           ),
         )

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -13,8 +13,10 @@ def compose(raw_initialize)
   workspace_path ||= Dir.pwd
 
   env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
-  File.write(
-    File.join(".ruby-lsp", "bundle_env"),
-    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
-  )
+
+  File.open(File.join(".ruby-lsp", "bundle_env"), "w") do |f|
+    f.flock(File::LOCK_EX)
+    f.write(env.map { |k, v| "#{k}=#{v}" }.join("\n"))
+    f.flush
+  end
 end

data/lib/ruby_lsp/server.rb

@@ -223,7 +223,8 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
       configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
-      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      @store.features_configuration.dig(:inlayHint) #: as !nil
+        .configuration.merge!(configured_hints) if configured_hints
 
       enabled_features = case configured_features
       when Array
@@ -294,6 +295,7 @@ module RubyLsp
             addon_detection: true,
             compose_bundle: true,
             go_to_relevant_file: true,
+            full_test_discovery: true,
           },
         ),
         serverInfo: {
@@ -488,7 +490,11 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-      inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
+      inlay_hint = Requests::InlayHints.new(
+        document,
+        @store.features_configuration.dig(:inlayHint), #: as !nil
+        dispatcher,
+      )
 
       if document.is_a?(RubyDocument) && document.should_index?
         # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
@@ -815,7 +821,7 @@ module RubyLsp
         return
       end
 
-      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+      hints_configurations = @store.features_configuration.dig(:inlayHint) #: as !nil
       dispatcher = Prism::Dispatcher.new
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
@@ -1393,7 +1399,9 @@ module RubyLsp
           Open3.capture3(
             Gem.ruby,
             "-I",
-            File.dirname(T.must(__dir__)),
+            File.dirname(
+              __dir__, #: as !nil
+            ),
             File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
             @global_state.workspace_uri.to_s,
             chdir: @global_state.workspace_path,

data/lib/ruby_lsp/setup_bundler.rb

@@ -405,12 +405,15 @@ module RubyLsp
     def correct_relative_remote_paths
       content = @custom_lockfile.read
       content.gsub!(/remote: (.*)/) do |match|
-        path = T.must(Regexp.last_match)[1]
+        last_match = Regexp.last_match #: as !nil
+        path = last_match[1]
 
         # We should only apply the correction if the remote is a relative path. It might also be a URI, like
         # `https://rubygems.org` or an absolute path, in which case we shouldn't do anything
         if path && !URI(path).scheme
-          "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
+          bundle_dir = @gemfile #: as !nil
+            .dirname
+          "remote: #{File.expand_path(path, bundle_dir)}"
         else
           match
         end

data/lib/ruby_lsp/static_docs.rb

@@ -3,7 +3,14 @@
 
 module RubyLsp
   # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs") #: String
+  STATIC_DOCS_PATH = File.join(
+    File.dirname(
+      File.dirname(
+        __dir__, #: as !nil
+      ),
+    ),
+    "static_docs",
+  ) #: String
 
   # A map of keyword => short documentation to be displayed on hover or completion
   KEYWORD_DOCS = {

data/lib/ruby_lsp/store.rb

@@ -46,7 +46,7 @@ module RubyLsp
       end
 
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
-      T.must(@state[uri.to_s])
+      @state[uri.to_s] #: as !nil
     rescue Errno::ENOENT
       raise NonExistingDocumentError, uri.to_s
     end
@@ -65,7 +65,8 @@ module RubyLsp
 
     #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
     def push_edits(uri:, edits:, version:)
-      T.must(@state[uri.to_s]).push_edits(edits, version: version)
+      @state[uri.to_s] #: as !nil
+        .push_edits(edits, version: version)
     end
 
     #: -> void

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -0,0 +1,152 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "singleton"
+
+module RubyLsp
+  class LspReporter
+    include Singleton
+
+    #: -> void
+    def initialize
+      port = ENV["RUBY_LSP_REPORTER_PORT"]
+      @io = if port
+        TCPSocket.new("localhost", port)
+      else
+        # For tests that don't spawn the TCP server
+        require "stringio"
+        StringIO.new
+      end #: IO | StringIO
+    end
+
+    #: -> void
+    def shutdown
+      send_message("finish")
+      @io.close
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def start_test(id:, uri:)
+      send_message("start", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def record_pass(id:, uri:)
+      send_message("pass", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, message: String, uri: URI::Generic) -> void
+    def record_fail(id:, message:, uri:)
+      send_message("fail", id: id, message: message, uri: uri.to_s)
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def record_skip(id:, uri:)
+      send_message("skip", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, message: String?, uri: URI::Generic) -> void
+    def record_error(id:, message:, uri:)
+      send_message("error", id: id, message: message, uri: uri.to_s)
+    end
+
+    # Gather the results returned by Coverage.result and format like the VS Code test explorer expects
+    #
+    # Coverage result format:
+    #
+    # Lines are reported in order as an array where each number is the number of times it was executed. For example,
+    # the following says that line 0 was executed 1 time and line 1 executed 3 times: [1, 3].
+    # Nil values represent lines for which coverage is not available, like empty lines, comments or keywords like
+    # `else`
+    #
+    # Branches are a hash containing the name of the branch and the location where it is found in tuples with the
+    # following elements: [NAME, ID, START_LINE, START_COLUMN, END_LINE, END_COLUMN] as the keys and the value is the
+    # number of times it was executed
+    #
+    # Methods are a similar hash [ClassName, :method_name, START_LINE, START_COLUMN, END_LINE, END_COLUMN] => NUMBER
+    # OF EXECUTIONS
+    #
+    # Example:
+    # {
+    #   "file_path" => {
+    #     "lines" => [1, 2, 3, nil],
+    #     "branches" => {
+    #       ["&.", 0, 6, 21, 6, 65] => { [:then, 1, 6, 21, 6, 65] => 0, [:else, 5, 7, 0, 7, 87] => 1 }
+    #     },
+    #     "methods" => {
+    #       ["Foo", :bar, 6, 21, 6, 65] => 0
+    #     }
+    # }
+    #: -> Hash[String, StatementCoverage]
+    def gather_coverage_results
+      # Ignore coverage results inside dependencies
+      bundle_path = Bundler.bundle_path.to_s
+      default_gems_path = File.dirname(RbConfig::CONFIG["rubylibdir"])
+
+      result = Coverage.result.reject do |file_path, _coverage_info|
+        file_path.start_with?(bundle_path, default_gems_path, "eval")
+      end
+
+      result.to_h do |file_path, coverage_info|
+        # Format the branch coverage information as VS Code expects it and then group it based on the start line of
+        # the conditional that causes the branching. We need to match each line coverage data with the branches that
+        # spawn from that line
+        branch_by_line = coverage_info[:branches]
+          .flat_map do |branch, data|
+            branch_name, _branch_id, branch_start_line, _branch_start_col, _branch_end_line, _branch_end_col = branch
+
+            data.map do |then_or_else, execution_count|
+              name, _id, start_line, start_column, end_line, end_column = then_or_else
+
+              {
+                groupingLine: branch_start_line,
+                executed: execution_count,
+                location: {
+                  start: { line: start_line, character: start_column },
+                  end: { line: end_line, character: end_column },
+                },
+                label: "#{branch_name} #{name}",
+              }
+            end
+          end
+          .group_by { |branch| branch[:groupingLine] }
+
+        # Format the line coverage information, gathering any branch coverage data associated with that line
+        data = coverage_info[:lines].filter_map.with_index do |execution_count, line_index|
+          next if execution_count.nil?
+
+          {
+            executed: execution_count,
+            location: { line: line_index, character: 0 },
+            branches: branch_by_line[line_index] || [],
+          }
+        end
+
+        # The expected format is URI => { executed: number_of_times_executed, location: { ... }, branches: [ ... ] }
+        [URI::Generic.from_path(path: File.expand_path(file_path)).to_s, data]
+      end
+    end
+
+    private
+
+    #: (method_name: String?, params: untyped) -> void
+    def send_message(method_name, **params)
+      json_message = { method: method_name, params: params }.to_json
+      @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+    end
+  end
+end
+
+if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+  # Auto start coverage when running tests under that profile. This avoids the user from having to configure coverage
+  # manually for their project or adding extra dependencies
+  require "coverage"
+  Coverage.start(:all)
+
+  at_exit do
+    coverage_results = RubyLsp::LspReporter.instance.gather_coverage_results
+    File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
+  end
+end