ruby-lsp 0.23.12 → 0.23.13

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

@@ -6,23 +6,20 @@ require "uri/file"
 module URI
   # Must be kept in sync with the one in Tapioca
   class Source < URI::File
-    COMPONENT = T.let(
-      [
-        :scheme,
-        :gem_name,
-        :gem_version,
-        :path,
-        :line_number,
-      ].freeze,
-      T::Array[Symbol],
-    )
+    COMPONENT = [
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze #: Array[Symbol]
 
     # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
     # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
     # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
     # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
     # have the uri gem in their own bundle and thus not use a compatible version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
@@ -50,8 +47,8 @@ module URI
 
       gem_version, path = v.delete_prefix("/").split("/", 2)
 
-      @gem_version = T.let(gem_version, T.nilable(String))
-      @path = T.let(path, T.nilable(String))
+      @gem_version = gem_version #: String?
+      @path = path #: String?
     end
 
     #: (String? v) -> bool
@@ -74,7 +71,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, T.untyped]) # rubocop:disable Style/ClassVars
+      @@schemes = @@schemes # rubocop:disable Style/ClassVars #: Hash[String, untyped]
       @@schemes["SOURCE"] = self
     end
   end

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

@@ -17,15 +17,11 @@ module RubyLsp
 
         #: -> void
         def initialize
-          @options =
-            T.let(
-              begin
-                opts = SyntaxTree::CLI::Options.new
-                opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
-                opts
-              end,
-              SyntaxTree::CLI::Options,
-            )
+          @options = begin
+            opts = SyntaxTree::CLI::Options.new
+            opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
+            opts
+          end #: SyntaxTree::CLI::Options
         end
 
         # @override

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

@@ -13,14 +13,14 @@ module RubyLsp
         #: String
         attr_reader :id, :label
 
-        #: (String id, String label, URI::Generic uri, Interface::Range range, Array[Symbol] tags) -> void
-        def initialize(id, label, uri, range, tags: [])
+        #: (String id, String label, URI::Generic uri, Interface::Range range, Symbol framework) -> void
+        def initialize(id, label, uri, range, framework:)
           @id = id
           @label = label
           @uri = uri
           @range = range
-          @tags = tags
-          @children = T.let({}, T::Hash[String, TestItem])
+          @tags = ["framework:#{framework}"] #: Array[String]
+          @children = {} #: Hash[String, TestItem]
         end
 
         #: (TestItem item) -> void
@@ -38,11 +38,6 @@ module RubyLsp
           @children.values
         end
 
-        #: (Symbol) -> bool
-        def tag?(tag)
-          @tags.include?(tag)
-        end
-
         #: -> Hash[Symbol, untyped]
         def to_hash
           {

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -23,7 +23,7 @@ module RubyLsp
         name = @item[:name]
         entries = @index[name]
 
-        parents = T.let(Set.new, T::Set[RubyIndexer::Entry::Namespace])
+        parents = Set.new #: Set[RubyIndexer::Entry::Namespace]
         return unless entries&.any?
 
         entries.each do |entry|

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -14,7 +14,7 @@ module RubyLsp
         super()
         @global_state = global_state
         @query = query
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @index = global_state.index #: RubyIndexer::Index
       end
 
       # @override

data/lib/ruby_lsp/response_builders/collection_response_builder.rb

@@ -11,7 +11,7 @@ module RubyLsp
       #: -> void
       def initialize
         super
-        @items = T.let([], T::Array[ResponseType])
+        @items = [] #: Array[ResponseType]
       end
 
       #: (ResponseType item) -> void

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -12,17 +12,14 @@ module RubyLsp
 
         #: -> void
         def initialize
-          @children = T.let([], T::Array[Interface::DocumentSymbol])
+          @children = [] #: Array[Interface::DocumentSymbol]
         end
       end
 
       #: -> void
       def initialize
         super
-        @stack = T.let(
-          [SymbolHierarchyRoot.new],
-          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
-        )
+        @stack = [SymbolHierarchyRoot.new] #: Array[(SymbolHierarchyRoot | Interface::DocumentSymbol)]
       end
 
       #: (Interface::DocumentSymbol symbol) -> void

data/lib/ruby_lsp/response_builders/hover.rb

@@ -12,14 +12,11 @@ module RubyLsp
       def initialize
         super
 
-        @response = T.let(
-          {
-            title: +"",
-            links: +"",
-            documentation: +"",
-          },
-          T::Hash[Symbol, String],
-        )
+        @response = {
+          title: +"",
+          links: +"",
+          documentation: +"",
+        } #: Hash[Symbol, String]
       end
 
       #: (String content, category: Symbol) -> void

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -6,50 +6,44 @@ module RubyLsp
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
-      TOKEN_TYPES = T.let(
-        {
-          namespace: 0,
-          type: 1,
-          class: 2,
-          enum: 3,
-          interface: 4,
-          struct: 5,
-          typeParameter: 6,
-          parameter: 7,
-          variable: 8,
-          property: 9,
-          enumMember: 10,
-          event: 11,
-          function: 12,
-          method: 13,
-          macro: 14,
-          keyword: 15,
-          modifier: 16,
-          comment: 17,
-          string: 18,
-          number: 19,
-          regexp: 20,
-          operator: 21,
-          decorator: 22,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
-
-      TOKEN_MODIFIERS = T.let(
-        {
-          declaration: 0,
-          definition: 1,
-          readonly: 2,
-          static: 3,
-          deprecated: 4,
-          abstract: 5,
-          async: 6,
-          modification: 7,
-          documentation: 8,
-          default_library: 9,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
+      TOKEN_TYPES = {
+        namespace: 0,
+        type: 1,
+        class: 2,
+        enum: 3,
+        interface: 4,
+        struct: 5,
+        typeParameter: 6,
+        parameter: 7,
+        variable: 8,
+        property: 9,
+        enumMember: 10,
+        event: 11,
+        function: 12,
+        method: 13,
+        macro: 14,
+        keyword: 15,
+        modifier: 16,
+        comment: 17,
+        string: 18,
+        number: 19,
+        regexp: 20,
+        operator: 21,
+        decorator: 22,
+      }.freeze #: Hash[Symbol, Integer]
+
+      TOKEN_MODIFIERS = {
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze #: Hash[Symbol, Integer]
 
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
@@ -57,7 +51,7 @@ module RubyLsp
       def initialize(code_units_cache)
         super()
         @code_units_cache = code_units_cache
-        @stack = T.let([], T::Array[SemanticToken])
+        @stack = [] #: Array[SemanticToken]
       end
 
       #: (Prism::Location location, Symbol type, ?Array[Symbol] modifiers) -> void
@@ -143,8 +137,8 @@ module RubyLsp
       class SemanticTokenEncoder
         #: -> void
         def initialize
-          @current_row = T.let(0, Integer)
-          @current_column = T.let(0, Integer)
+          @current_row = 0 #: Integer
+          @current_column = 0 #: Integer
         end
 
         #: (Array[SemanticToken] tokens) -> Array[Integer]

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -9,7 +9,7 @@ module RubyLsp
       #: -> void
       def initialize
         super
-        @signature_help = T.let(nil, ResponseType)
+        @signature_help = nil #: ResponseType
       end
 
       #: (ResponseType signature_help) -> void

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -11,7 +11,7 @@ module RubyLsp
       #: -> void
       def initialize
         super
-        @items = T.let({}, T::Hash[String, ResponseType])
+        @items = {} #: Hash[String, ResponseType]
       end
 
       #: (ResponseType item) -> void

data/lib/ruby_lsp/ruby_document.rb

@@ -36,24 +36,13 @@ module RubyLsp
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
-        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+        queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
-        parent = T.let(nil, T.nilable(Prism::Node))
-        nesting_nodes = T.let(
-          [],
-          T::Array[T.any(
-            Prism::ClassNode,
-            Prism::ModuleNode,
-            Prism::SingletonClassNode,
-            Prism::DefNode,
-            Prism::BlockNode,
-            Prism::LambdaNode,
-            Prism::ProgramNode,
-          )],
-        )
+        parent = nil #: Prism::Node?
+        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] # rubocop:disable Layout/LineLength
 
         nesting_nodes << node if node.is_a?(Prism::ProgramNode)
-        call_node = T.let(nil, T.nilable(Prism::CallNode))
+        call_node = nil #: Prism::CallNode?
 
         until queue.empty?
           candidate = queue.shift
@@ -143,10 +132,8 @@ module RubyLsp
     #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache = @parse_result
+        .code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
     # @override
@@ -197,7 +184,7 @@ module RubyLsp
       start_position, end_position = find_index_by_position(range[:start], range[:end])
 
       desired_range = (start_position...end_position)
-      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+      queue = @parse_result.value.child_nodes.compact #: Array[Prism::Node?]
 
       until queue.empty?
         candidate = queue.shift

data/lib/ruby_lsp/ruby_lsp_reporter_plugin.rb

@@ -1,18 +1,22 @@
 # typed: strict
 # frozen_string_literal: true
 
+begin
+  require "minitest"
+rescue LoadError
+  return
+end
+
 require_relative "test_reporter"
 require "ruby_indexer/lib/ruby_indexer/uri"
 
-require "minitest"
-
 module Minitest
   module Reporters
     class RubyLspReporter < ::Minitest::AbstractReporter
       class << self
         #: (Hash[untyped, untyped]) -> void
         def minitest_plugin_init(_options)
-          Minitest.reporter.reporters = [RubyLspReporter.new]
+          Minitest.reporter.reporters << RubyLspReporter.new
         end
       end
 
@@ -54,7 +58,6 @@ module Minitest
       def record_skip(result)
         RubyLsp::TestReporter.record_skip(
           id: id_from_result(result),
-          message: result.failure.message,
           uri: uri_from_result(result),
         )
       end

data/lib/ruby_lsp/scope.rb

@@ -11,7 +11,7 @@ module RubyLsp
       @parent = parent
 
       # A hash of name => type
-      @locals = T.let({}, T::Hash[Symbol, Local])
+      @locals = {} #: Hash[Symbol, Local]
     end
 
     # Add a new local to this scope. The types should only be `:parameter` or `:variable`

data/lib/ruby_lsp/server.rb

@@ -1459,10 +1459,18 @@ module RubyLsp
     #: (Hash[Symbol, untyped] message) -> void
     def resolve_test_commands(message)
       items = message.dig(:params, :items)
+      commands = Listeners::TestStyle.resolve_test_commands(items)
+
+      Addon.addons.each do |addon|
+        commands.concat(addon.resolve_test_commands(items))
+      end
 
       send_message(Result.new(
         id: message[:id],
-        response: { commands: Listeners::TestStyle.resolve_test_commands(items) },
+        response: {
+          commands: commands,
+          reporterPaths: [Listeners::TestStyle::MINITEST_REPORTER_PATH, Listeners::TestStyle::TEST_UNIT_REPORTER_PATH],
+        },
       ))
     end
   end

data/lib/ruby_lsp/setup_bundler.rb

@@ -25,45 +25,42 @@ module RubyLsp
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
-    FOUR_HOURS = T.let(4 * 60 * 60, Integer)
+    FOUR_HOURS = 4 * 60 * 60 #: Integer
 
     #: (String project_path, **untyped options) -> void
     def initialize(project_path, **options)
       @project_path = project_path
-      @branch = T.let(options[:branch], T.nilable(String))
-      @launcher = T.let(options[:launcher], T.nilable(T::Boolean))
+      @branch = options[:branch] #: String?
+      @launcher = options[:launcher] #: bool?
       patch_thor_to_print_progress_to_stderr! if @launcher
 
       # Regular bundle paths
-      @gemfile = T.let(
-        begin
-          Bundler.default_gemfile
-        rescue Bundler::GemfileNotFound
-          nil
-        end,
-        T.nilable(Pathname),
-      )
-      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
+      @gemfile = begin
+        Bundler.default_gemfile
+      rescue Bundler::GemfileNotFound
+        nil
+      end #: Pathname?
+      @lockfile = @gemfile ? Bundler.default_lockfile : nil #: Pathname?
 
-      @gemfile_hash = T.let(@gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil, T.nilable(String))
-      @lockfile_hash = T.let(@lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil, T.nilable(String))
+      @gemfile_hash = @gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil #: String?
+      @lockfile_hash = @lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil #: String?
 
-      @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
+      @gemfile_name = @gemfile&.basename&.to_s || "Gemfile" #: String
 
       # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(@project_path), Pathname)
-      @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
-      @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
-      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
-      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
-      @error_path = T.let(@custom_dir + "install_error", Pathname)
-      @already_composed_path = T.let(@custom_dir + "bundle_is_composed", Pathname)
+      @custom_dir = Pathname.new(".ruby-lsp").expand_path(@project_path) #: Pathname
+      @custom_gemfile = @custom_dir + @gemfile_name #: Pathname
+      @custom_lockfile = @custom_dir + (@lockfile&.basename || "Gemfile.lock") #: Pathname
+      @lockfile_hash_path = @custom_dir + "main_lockfile_hash" #: Pathname
+      @last_updated_path = @custom_dir + "last_updated" #: Pathname
+      @error_path = @custom_dir + "install_error" #: Pathname
+      @already_composed_path = @custom_dir + "bundle_is_composed" #: Pathname
 
       dependencies, bundler_version = load_dependencies
-      @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
-      @bundler_version = T.let(bundler_version, T.nilable(Gem::Version))
-      @rails_app = T.let(rails_app?, T::Boolean)
-      @retry = T.let(false, T::Boolean)
+      @dependencies = dependencies #: Hash[String, untyped]
+      @bundler_version = bundler_version #: Gem::Version?
+      @rails_app = rails_app? #: bool
+      @retry = false #: bool
     end
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
@@ -130,21 +127,18 @@ module RubyLsp
 
     #: -> Hash[String, untyped]
     def composed_bundle_dependencies
-      @composed_bundle_dependencies ||= T.let(
-        begin
-          original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
-
-          if @custom_lockfile.exist?
-            ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
-            Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
-          else
-            {}
-          end
-        ensure
-          ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
-        end,
-        T.nilable(T::Hash[String, T.untyped]),
-      )
+      @composed_bundle_dependencies ||= begin
+        original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
+
+        if @custom_lockfile.exist?
+          ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
+          Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+        else
+          {}
+        end
+      ensure
+        ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
+      end #: Hash[String, untyped]?
     end
 
     #: -> void
@@ -269,7 +263,7 @@ module RubyLsp
       T.unsafe(ENV).merge!(env)
 
       unless should_update && !force_install
-        Bundler::CLI::Install.new({}).run
+        Bundler::CLI::Install.new({ "no-cache" => true }).run
         correct_relative_remote_paths if @custom_lockfile.exist?
         return env
       end

data/lib/ruby_lsp/static_docs.rb

@@ -3,13 +3,10 @@
 
 module RubyLsp
   # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = T.let(File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs"), String)
+  STATIC_DOCS_PATH = File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs") #: String
 
   # A map of keyword => short documentation to be displayed on hover or completion
-  KEYWORD_DOCS = T.let(
-    {
-      "yield" => "Invokes the passed block with the given arguments",
-    }.freeze,
-    T::Hash[String, String],
-  )
+  KEYWORD_DOCS = {
+    "yield" => "Invokes the passed block with the given arguments",
+  }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -14,18 +14,15 @@ module RubyLsp
     #: (GlobalState global_state) -> void
     def initialize(global_state)
       @global_state = global_state
-      @state = T.let({}, T::Hash[String, Document[T.untyped]])
-      @features_configuration = T.let(
-        {
-          inlayHint: RequestConfig.new({
-            enableAll: false,
-            implicitRescue: false,
-            implicitHashValue: false,
-          }),
-        },
-        T::Hash[Symbol, RequestConfig],
-      )
-      @client_name = T.let("Unknown", String)
+      @state = {} #: Hash[String, Document[untyped]]
+      @features_configuration = {
+        inlayHint: RequestConfig.new({
+          enableAll: false,
+          implicitRescue: false,
+          implicitHashValue: false,
+        }),
+      } #: Hash[Symbol, RequestConfig]
+      @client_name = "Unknown" #: String
     end
 
     #: (URI::Generic uri) -> Document[untyped]