ruby-lsp 0.23.10 → 0.23.12

data/lib/ruby_indexer/test/configuration_test.rb

@@ -12,7 +12,7 @@ module RubyIndexer
     end
 
     def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
+      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*"] })
       uris = @config.indexable_uris
 
       bundle_path = Bundler.bundle_path.join("gems")
@@ -39,7 +39,11 @@ module RubyIndexer
         next if lazy_spec.name == "ruby-lsp"
 
         spec = Gem::Specification.find_by_name(lazy_spec.name)
-        assert(uris.none? { |uri| uri.full_path.start_with?("#{spec.full_gem_path}/test/") })
+
+        test_uris = uris.select do |uri|
+          File.fnmatch?(File.join(spec.full_gem_path, "test/**/*"), uri.full_path, File::Constants::FNM_PATHNAME)
+        end
+        assert_empty(test_uris)
       rescue Gem::MissingSpecError
         # Transitive dependencies might be missing when running tests on Windows
       end
@@ -235,5 +239,31 @@ module RubyIndexer
         end
       end
     end
+
+    def test_indexables_include_non_test_files_in_test_directories
+      # In order to linearize test parent classes and accurately detect the framework being used, then intermediate
+      # parent classes _must_ also be indexed. Otherwise, we have no way of linearizing the rest of the ancestors to
+      # determine what the test class ultimately inherits from.
+      #
+      # Therefore, we need to ensure that test files are excluded, but non test files inside test directories have to be
+      # indexed
+      FileUtils.touch("test/test_case.rb")
+
+      uris = @config.indexable_uris
+      project_paths = uris.filter_map do |uri|
+        path = uri.full_path
+        next if path.start_with?(Bundler.bundle_path.to_s) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+        Pathname.new(path).relative_path_from(Dir.pwd).to_s
+      end
+
+      begin
+        assert_includes(project_paths, "test/requests/support/expectations_test_runner.rb")
+        assert_includes(project_paths, "test/test_helper.rb")
+        assert_includes(project_paths, "test/test_case.rb")
+      ensure
+        FileUtils.rm("test/test_case.rb")
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -2161,5 +2161,26 @@ module RubyIndexer
 
       assert_equal("@@hello", candidates.first&.name)
     end
+
+    def test_actual_nesting
+      assert_equal(["Foo"], Index.actual_nesting([], "Foo"))
+      assert_equal(["TopLevel", "Foo"], Index.actual_nesting(["First", "::TopLevel"], "Foo"))
+      assert_equal(["TopLevel", "Another", "Foo"], Index.actual_nesting(["::TopLevel", "Another"], "Foo"))
+      assert_equal(["TopLevel"], Index.actual_nesting(["First", "::TopLevel"], nil))
+    end
+
+    def test_constant_name
+      node = Prism.parse("class var::Foo; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class ; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class method_call; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class Foo; end").value.statements.body.first.constant_path
+      assert_equal("Foo", Index.constant_name(node))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -926,14 +926,14 @@ module RubyIndexer
 
     private
 
-    sig { params(entry: Entry::Method, call_string: String).void }
+    #: (Entry::Method entry, String call_string) -> void
     def assert_signature_matches(entry, call_string)
       sig = T.must(entry.signatures.first)
       arguments = parse_prism_args(call_string)
       assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
     end
 
-    sig { params(entry: Entry::Method, call_string: String).void }
+    #: (Entry::Method entry, String call_string) -> void
     def refute_signature_matches(entry, call_string)
       sig = T.must(entry.signatures.first)
       arguments = parse_prism_args(call_string)

data/lib/ruby_lsp/addon.rb

@@ -35,32 +35,24 @@ module RubyLsp
     class IncompatibleApiError < StandardError; end
 
     class << self
-      extend T::Sig
-
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :addons
 
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :file_watcher_addons
 
-      sig { returns(T::Array[T.class_of(Addon)]) }
+      #: Array[singleton(Addon)]
       attr_reader :addon_classes
 
       # Automatically track and instantiate add-on classes
-      sig { params(child_class: T.class_of(Addon)).void }
+      #: (singleton(Addon) child_class) -> void
       def inherited(child_class)
         addon_classes << child_class
         super
       end
 
       # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
-      sig do
-        params(
-          global_state: GlobalState,
-          outgoing_queue: Thread::Queue,
-          include_project_addons: T::Boolean,
-        ).returns(T::Array[StandardError])
-      end
+      #: (GlobalState global_state, Thread::Queue outgoing_queue, ?include_project_addons: bool) -> Array[StandardError]
       def load_addons(global_state, outgoing_queue, include_project_addons: true)
         # Require all add-ons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
@@ -98,7 +90,7 @@ module RubyLsp
       end
 
       # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
-      sig { void }
+      #: -> void
       def unload_addons
         @addons.each(&:deactivate)
         @addons.clear
@@ -112,7 +104,7 @@ module RubyLsp
       # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
       # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
       # the responsibility of the add-ons using this API to handle these errors appropriately.
-      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      #: (String addon_name, *String version_constraints) -> Addon
       def get(addon_name, *version_constraints)
         if version_constraints.empty?
           raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
@@ -144,7 +136,7 @@ module RubyLsp
       #   end
       # end
       # ```
-      sig { params(version_constraints: String).void }
+      #: (*String version_constraints) -> void
       def depend_on_ruby_lsp!(*version_constraints)
         version_object = Gem::Version.new(RubyLsp::VERSION)
 
@@ -155,23 +147,23 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def initialize
       @errors = T.let([], T::Array[StandardError])
     end
 
-    sig { params(error: StandardError).returns(T.self_type) }
+    #: (StandardError error) -> self
     def add_error(error)
       @errors << error
       self
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def error?
       @errors.any?
     end
 
-    sig { returns(String) }
+    #: -> String
     def formatted_errors
       <<~ERRORS
         #{name}:
@@ -179,7 +171,7 @@ module RubyLsp
       ERRORS
     end
 
-    sig { returns(String) }
+    #: -> String
     def errors_details
       @errors.map(&:full_message).join("\n\n")
     end
@@ -207,69 +199,42 @@ module RubyLsp
     # original request so that the response is delegated to the correct add-on and must override this method to handle
     # the response
     # https://microsoft.github.io/language-server-protocol/specification#window_showMessageRequest
-    sig { overridable.params(title: String).void }
+    # @overridable
+    #: (String title) -> void
     def handle_window_show_message_response(title); end
 
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        uri: URI::Generic,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
     def create_code_lens_listener(response_builder, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::Hover,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_hover_listener(response_builder, node_context, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::DocumentSymbol,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
     def create_document_symbol_listener(response_builder, dispatcher); end
 
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::SemanticHighlighting,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::SemanticHighlighting response_builder, Prism::Dispatcher dispatcher) -> void
     def create_semantic_highlighting_listener(response_builder, dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-          Interface::Location,
-          Interface::LocationLink,
-        )],
-        uri: URI::Generic,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_definition_listener(response_builder, uri, node_context, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
     def create_completion_listener(response_builder, node_context, dispatcher, uri); end
+
+    # Creates a new Discover Tests listener. This method is invoked on every DiscoverTests request
+    # @overridable
+    #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+    def create_discover_tests_listener(response_builder, dispatcher, uri); end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -8,7 +8,7 @@ module RubyLsp
 
     abstract!
 
-    sig { params(options: T.untyped).void }
+    #: (**untyped options) -> void
     def initialize(**options)
       @test_mode = T.let(options[:test_mode], T.nilable(T::Boolean))
       @setup_error = T.let(options[:setup_error], T.nilable(StandardError))
@@ -41,7 +41,7 @@ module RubyLsp
       process_message(initialize_request) if initialize_request
     end
 
-    sig { void }
+    #: -> void
     def start
       @reader.read do |message|
         method = message[:method]
@@ -90,7 +90,8 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+          "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -107,7 +108,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def run_shutdown
       @incoming_queue.clear
       @outgoing_queue.clear
@@ -121,13 +122,13 @@ module RubyLsp
     end
 
     # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
-    sig { returns(T.untyped) }
+    #: -> untyped
     def pop_response
       @outgoing_queue.pop
     end
 
     # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def push_message(message)
       @incoming_queue << message
     end
@@ -138,13 +139,13 @@ module RubyLsp
     sig { abstract.void }
     def shutdown; end
 
-    sig { params(id: Integer, message: String, type: Integer).void }
+    #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
       send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
       send_message(Notification.window_show_message(message, type: type))
     end
 
-    sig { returns(Thread) }
+    #: -> Thread
     def new_worker
       Thread.new do
         while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
@@ -164,7 +165,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    #: ((Result | Error | Notification | Request) message) -> void
     def send_message(message)
       # When we're shutting down the server, there's a small race condition between closing the thread queues and
       # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
@@ -175,12 +176,12 @@ module RubyLsp
       @current_request_id += 1 if message.is_a?(Request)
     end
 
-    sig { params(id: Integer).void }
+    #: (Integer id) -> void
     def send_empty_response(id)
       send_message(Result.new(id: id, response: nil))
     end
 
-    sig { params(message: String, type: Integer).void }
+    #: (String message, ?type: Integer) -> void
     def send_log_message(message, type: Constant::MessageType::LOG)
       send_message(Notification.window_log_message(message, type: Constant::MessageType::LOG))
     end

data/lib/ruby_lsp/client_capabilities.rb

@@ -5,16 +5,14 @@ module RubyLsp
   # This class stores all client capabilities that the Ruby LSP and its add-ons depend on to ensure that we're
   # not enabling functionality unsupported by the editor connecting to the server
   class ClientCapabilities
-    extend T::Sig
-
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :supports_watching_files,
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
       :supports_progress,
       :supports_diagnostic_refresh
 
-    sig { void }
+    #: -> void
     def initialize
       # The editor supports watching files. This requires two capabilities: dynamic registration and relative pattern
       # support
@@ -38,7 +36,7 @@ module RubyLsp
       @supports_diagnostic_refresh = T.let(false, T::Boolean)
     end
 
-    sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] capabilities) -> void
     def apply_client_capabilities(capabilities)
       workspace_capabilities = capabilities[:workspace] || {}
 
@@ -65,7 +63,7 @@ module RubyLsp
       @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_rename?
       @supported_resource_operations.include?("rename")
     end

data/lib/ruby_lsp/document.rb

@@ -25,28 +25,28 @@ module RubyLsp
 
     abstract!
 
-    sig { returns(ParseResultType) }
+    #: ParseResultType
     attr_reader :parse_result
 
-    sig { returns(String) }
+    #: String
     attr_reader :source
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :version
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :uri
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T.nilable(Edit)) }
+    #: Edit?
     attr_reader :last_edit
 
-    sig { returns(T.any(Interface::SemanticTokens, Object)) }
+    #: (Interface::SemanticTokens | Object)
     attr_accessor :semantic_tokens
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       @source = source
       @version = version
@@ -61,7 +61,7 @@ module RubyLsp
       parse!
     end
 
-    sig { params(other: Document[T.untyped]).returns(T::Boolean) }
+    #: (Document[untyped] other) -> bool
     def ==(other)
       self.class == other.class && uri == other.uri && @source == other.source
     end
@@ -69,13 +69,7 @@ module RubyLsp
     sig { abstract.returns(LanguageId) }
     def language_id; end
 
-    sig do
-      type_parameters(:T)
-        .params(
-          request_name: String,
-          block: T.proc.params(document: Document[ParseResultType]).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
       return cached if cached != EMPTY_CACHE
@@ -85,17 +79,17 @@ module RubyLsp
       result
     end
 
-    sig { type_parameters(:T).params(request_name: String, value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    #: [T] (String request_name, T value) -> T
     def cache_set(request_name, value)
       @cache[request_name] = value
     end
 
-    sig { params(request_name: String).returns(T.untyped) }
+    #: (String request_name) -> untyped
     def cache_get(request_name)
       @cache[request_name]
     end
 
-    sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
+    #: (Array[Hash[Symbol, untyped]] edits, version: Integer) -> void
     def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
@@ -132,17 +126,12 @@ module RubyLsp
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def past_expensive_limit?
       @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
     end
 
-    sig do
-      params(
-        start_pos: T::Hash[Symbol, T.untyped],
-        end_pos: T.nilable(T::Hash[Symbol, T.untyped]),
-      ).returns([Integer, T.nilable(Integer)])
-    end
+    #: (Hash[Symbol, untyped] start_pos, ?Hash[Symbol, untyped]? end_pos) -> [Integer, Integer?]
     def find_index_by_position(start_pos, end_pos = nil)
       @global_state.synchronize do
         scanner = create_scanner
@@ -154,7 +143,7 @@ module RubyLsp
 
     private
 
-    sig { returns(Scanner) }
+    #: -> Scanner
     def create_scanner
       Scanner.new(@source, @encoding)
     end
@@ -165,10 +154,10 @@ module RubyLsp
 
       abstract!
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
+      #: Hash[Symbol, untyped]
       attr_reader :range
 
-      sig { params(range: T::Hash[Symbol, T.untyped]).void }
+      #: (Hash[Symbol, untyped] range) -> void
       def initialize(range)
         @range = range
       end
@@ -185,7 +174,7 @@ module RubyLsp
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
       SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
 
-      sig { params(source: String, encoding: Encoding).void }
+      #: (String source, Encoding encoding) -> void
       def initialize(source, encoding)
         @current_line = T.let(0, Integer)
         @pos = T.let(0, Integer)
@@ -194,7 +183,7 @@ module RubyLsp
       end
 
       # Finds the character index inside the source string for a given line and column
-      sig { params(position: T::Hash[Symbol, T.untyped]).returns(Integer) }
+      #: (Hash[Symbol, untyped] position) -> Integer
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
@@ -224,7 +213,7 @@ module RubyLsp
 
       # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
       # right character in the UTF-8 representation
-      sig { params(current_position: Integer, requested_position: Integer).returns(Integer) }
+      #: (Integer current_position, Integer requested_position) -> Integer
       def utf_16_character_position_correction(current_position, requested_position)
         utf16_unicode_correction = 0