ruby-lsp 0.23.11 → 0.23.12

data/lib/ruby_lsp/global_state.rb

@@ -3,39 +3,37 @@
 
 module RubyLsp
   class GlobalState
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :test_library
 
-    sig { returns(String) }
+    #: String
     attr_accessor :formatter
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :has_type_checker
 
-    sig { returns(RubyIndexer::Index) }
+    #: RubyIndexer::Index
     attr_reader :index
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :top_level_bundle
 
-    sig { returns(TypeInferrer) }
+    #: TypeInferrer
     attr_reader :type_inferrer
 
-    sig { returns(ClientCapabilities) }
+    #: ClientCapabilities
     attr_reader :client_capabilities
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :workspace_uri
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :telemetry_machine_id
 
-    sig { void }
+    #: -> void
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
       @encoding = T.let(Encoding::UTF_8, Encoding)
@@ -63,33 +61,33 @@ module RubyLsp
       @telemetry_machine_id = T.let(nil, T.nilable(String))
     end
 
-    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    #: [T] { -> T } -> T
     def synchronize(&block)
       @mutex.synchronize(&block)
     end
 
-    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    #: (String addon_name) -> Hash[Symbol, untyped]?
     def settings_for_addon(addon_name)
       @addon_settings[addon_name]
     end
 
-    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    #: (String identifier, Requests::Support::Formatter instance) -> void
     def register_formatter(identifier, instance)
       @supported_formatters[identifier] = instance
     end
 
-    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    #: -> Requests::Support::Formatter?
     def active_formatter
       @supported_formatters[@formatter]
     end
 
-    sig { returns(T::Array[Requests::Support::Formatter]) }
+    #: -> Array[Requests::Support::Formatter]
     def active_linters
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
     # Applies the options provided by the editor and returns an array of notifications to send back to the client
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
+    #: (Hash[Symbol, untyped] options) -> Array[Notification]
     def apply_options(options)
       notifications = []
       direct_dependencies = gather_direct_dependencies
@@ -183,17 +181,17 @@ module RubyLsp
       notifications
     end
 
-    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    #: (Symbol flag) -> bool?
     def enabled_feature?(flag)
       @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
-    sig { returns(String) }
+    #: -> String
     def workspace_path
       T.must(@workspace_uri.to_standardized_path)
     end
 
-    sig { returns(String) }
+    #: -> String
     def encoding_name
       case @encoding
       when Encoding::UTF_8
@@ -205,14 +203,14 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_watching_files
       @client_capabilities.supports_watching_files
     end
 
     private
 
-    sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] direct_dependencies, Array[String] all_dependencies) -> String
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
       return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
@@ -228,7 +226,7 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    #: (Array[String] dependencies, Array[String] all_dependencies) -> Array[String]
     def detect_linters(dependencies, all_dependencies)
       linters = []
 
@@ -239,7 +237,7 @@ module RubyLsp
       linters
     end
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] dependencies) -> String
     def detect_test_library(dependencies)
       if dependencies.any?(/^rspec/)
         "rspec"
@@ -259,7 +257,7 @@ module RubyLsp
       end
     end
 
-    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    #: (Array[String] dependencies) -> bool
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
@@ -268,17 +266,17 @@ module RubyLsp
       false
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def bin_rails_present
       File.exist?(File.join(workspace_path, "bin/rails"))
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def dot_rubocop_yml_present
       File.exist?(File.join(workspace_path, ".rubocop.yml"))
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
 
@@ -288,14 +286,14 @@ module RubyLsp
       []
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gemspec_dependencies
       (Bundler.locked_gems&.sources || [])
         .grep(Bundler::Source::Gemspec)
         .flat_map { _1.gemspec&.dependencies&.map(&:name) }
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_and_indirect_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
       Bundler.locked_gems&.specs&.map(&:name) || []

data/lib/ruby_lsp/internal.rb

@@ -25,6 +25,7 @@ require "fileutils"
 require "open3"
 require "securerandom"
 require "shellwords"
+require "set"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -79,6 +80,7 @@ require "ruby_lsp/requests/document_link"
 require "ruby_lsp/requests/document_symbol"
 require "ruby_lsp/requests/folding_ranges"
 require "ruby_lsp/requests/formatting"
+require "ruby_lsp/requests/go_to_relevant_file"
 require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -6,7 +6,6 @@ require "shellwords"
 module RubyLsp
   module Listeners
     class CodeLens
-      extend T::Sig
       include Requests::Support::Common
 
       BASE_COMMAND = T.let(
@@ -20,18 +19,9 @@ module RubyLsp
       )
       ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
-      DESCRIBE_KEYWORD = T.let(:describe, Symbol)
-      IT_KEYWORD = T.let(:it, Symbol)
       DYNAMIC_REFERENCE_MARKER = T.let("<dynamic_reference>", String)
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          global_state: GlobalState,
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
         @global_state = global_state
@@ -59,7 +49,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         @visibility_stack.push([:public, :public])
         class_name = node.constant_path.slice
@@ -79,7 +69,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         @visibility_stack.pop
         @group_stack.pop
@@ -91,7 +81,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         @def_depth += 1
         return if @def_depth > 1
@@ -114,12 +104,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
         @def_depth -= 1
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         if (path = namespace_constant_name(node))
           @group_stack.push(path)
@@ -128,12 +118,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         @group_stack.pop
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         name = node.name
         arguments = node.arguments
@@ -151,23 +141,21 @@ module RubyLsp
           return
         end
 
-        if [DESCRIBE_KEYWORD, IT_KEYWORD].include?(name)
-          case name
-          when DESCRIBE_KEYWORD
-            add_spec_code_lens(node, kind: :group)
-            @group_id_stack.push(@group_id)
-            @group_id += 1
-          when IT_KEYWORD
-            add_spec_code_lens(node, kind: :example)
-          end
+        case name
+        when :describe
+          add_spec_code_lens(node, kind: :group)
+          @group_id_stack.push(@group_id)
+          @group_id += 1
+        when :it, :specify # `specify` is an alias for `it`
+          add_spec_code_lens(node, kind: :example)
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_leave(node)
         _, prev_visibility = @visibility_stack.pop
         @visibility_stack.push([prev_visibility, prev_visibility])
-        if node.name == DESCRIBE_KEYWORD
+        if node.name == :describe
           @group_id_stack.pop
           @group_stack.pop
         end
@@ -175,7 +163,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol, id: String).void }
+      #: (Prism::Node node, name: String, command: String, kind: Symbol, ?id: String) -> void
       def add_test_code_lens(node, name:, command:, kind:, id: name)
         # don't add code lenses if the test library is not supported or unknown
         return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
@@ -221,13 +209,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          group_stack: T::Array[String],
-          spec_name: T.nilable(String),
-          method_name: T.nilable(String),
-        ).returns(String)
-      end
+      #: (?group_stack: Array[String], ?spec_name: String?, ?method_name: String?) -> String
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         path = T.must(@path)
         command = BASE_COMMAND
@@ -274,7 +256,7 @@ module RubyLsp
         command
       end
 
-      sig { params(node: Prism::CallNode, kind: Symbol).void }
+      #: (Prism::CallNode node, kind: Symbol) -> void
       def add_spec_code_lens(node, kind:)
         arguments = node.arguments
         return unless arguments
@@ -312,7 +294,7 @@ module RubyLsp
         end
       end
 
-      sig { params(group_stack: T::Array[String], method_name: T.nilable(String)).returns(String) }
+      #: (group_stack: Array[String], ?method_name: String?) -> String
       def generate_fully_qualified_id(group_stack:, method_name: nil)
         if method_name
           # For tests, this will be the test class and method name: `Foo::BarTest#test_baz`.

data/lib/ruby_lsp/listeners/completion.rb

@@ -4,7 +4,6 @@
 module RubyLsp
   module Listeners
     class Completion
-      extend T::Sig
       include Requests::Support::Common
 
       KEYWORDS = [
@@ -51,17 +50,7 @@ module RubyLsp
         "__LINE__",
       ].freeze
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          global_state: GlobalState,
-          node_context: NodeContext,
-          sorbet_level: RubyDocument::SorbetLevel,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-          trigger_character: T.nilable(String),
-        ).void
-      end
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, GlobalState global_state, NodeContext node_context, RubyDocument::SorbetLevel sorbet_level, Prism::Dispatcher dispatcher, URI::Generic uri, String? trigger_character) -> void
       def initialize( # rubocop:disable Metrics/ParameterLists
         response_builder,
         global_state,
@@ -107,7 +96,7 @@ module RubyLsp
       end
 
       # Handle completion on regular constant references (e.g. `Bar`)
-      sig { params(node: Prism::ConstantReadNode).void }
+      #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
@@ -131,7 +120,7 @@ module RubyLsp
       end
 
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
-      sig { params(node: Prism::ConstantPathNode).void }
+      #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
@@ -149,7 +138,7 @@ module RubyLsp
         constant_path_completion(name, range_from_location(node.location))
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
@@ -193,99 +182,99 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      #: (Prism::GlobalVariableAndWriteNode node) -> void
       def on_global_variable_and_write_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      #: (Prism::GlobalVariableOperatorWriteNode node) -> void
       def on_global_variable_operator_write_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      #: (Prism::GlobalVariableOrWriteNode node) -> void
       def on_global_variable_or_write_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::GlobalVariableReadNode).void }
+      #: (Prism::GlobalVariableReadNode node) -> void
       def on_global_variable_read_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      #: (Prism::GlobalVariableTargetNode node) -> void
       def on_global_variable_target_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      #: (Prism::GlobalVariableWriteNode node) -> void
       def on_global_variable_write_node_enter(node)
         handle_global_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::InstanceVariableReadNode).void }
+      #: (Prism::InstanceVariableReadNode node) -> void
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::InstanceVariableWriteNode).void }
+      #: (Prism::InstanceVariableWriteNode node) -> void
       def on_instance_variable_write_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      #: (Prism::InstanceVariableAndWriteNode node) -> void
       def on_instance_variable_and_write_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      #: (Prism::InstanceVariableOperatorWriteNode node) -> void
       def on_instance_variable_operator_write_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      #: (Prism::InstanceVariableOrWriteNode node) -> void
       def on_instance_variable_or_write_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      #: (Prism::InstanceVariableTargetNode node) -> void
       def on_instance_variable_target_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      #: (Prism::ClassVariableOperatorWriteNode node) -> void
       def on_class_variable_operator_write_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      #: (Prism::ClassVariableOrWriteNode node) -> void
       def on_class_variable_or_write_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::ClassVariableTargetNode).void }
+      #: (Prism::ClassVariableTargetNode node) -> void
       def on_class_variable_target_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::ClassVariableReadNode).void }
+      #: (Prism::ClassVariableReadNode node) -> void
       def on_class_variable_read_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.location)
       end
 
-      sig { params(node: Prism::ClassVariableWriteNode).void }
+      #: (Prism::ClassVariableWriteNode node) -> void
       def on_class_variable_write_node_enter(node)
         handle_class_variable_completion(node.name.to_s, node.name_loc)
       end
 
       private
 
-      sig { params(name: String, range: Interface::Range).void }
+      #: (String name, Interface::Range range) -> void
       def constant_path_completion(name, range)
         top_level_reference = if name.start_with?("::")
           name = name.delete_prefix("::")
@@ -340,7 +329,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String, location: Prism::Location).void }
+      #: (String name, Prism::Location location) -> void
       def handle_global_variable_completion(name, location)
         candidates = @index.prefix_search(name)
 
@@ -363,7 +352,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String, location: Prism::Location).void }
+      #: (String name, Prism::Location location) -> void
       def handle_class_variable_completion(name, location)
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -394,7 +383,7 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(name: String, location: Prism::Location).void }
+      #: (String name, Prism::Location location) -> void
       def handle_instance_variable_completion(name, location)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
@@ -428,7 +417,7 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def complete_require(node)
         arguments_node = node.arguments
         return unless arguments_node
@@ -444,7 +433,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def complete_require_relative(node)
         arguments_node = node.arguments
         return unless arguments_node
@@ -476,7 +465,7 @@ module RubyLsp
         # might fail with EPERM
       end
 
-      sig { params(node: Prism::CallNode, name: String).void }
+      #: (Prism::CallNode node, String name) -> void
       def complete_methods(node, name)
         # If the node has a receiver, then we don't need to provide local nor keyword completions. Sorbet can provide
         # local and keyword completion for any file with a Sorbet level of true or higher
@@ -540,7 +529,7 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
-      sig { params(node: Prism::CallNode, name: String).void }
+      #: (Prism::CallNode node, String name) -> void
       def add_local_completions(node, name)
         range = range_from_location(T.must(node.message_loc))
 
@@ -560,7 +549,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode, name: String).void }
+      #: (Prism::CallNode node, String name) -> void
       def add_keyword_completions(node, name)
         range = range_from_location(T.must(node.message_loc))
 
@@ -578,7 +567,7 @@ module RubyLsp
         end
       end
 
-      sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
+      #: (String label, Prism::StringNode node) -> Interface::CompletionItem
       def build_completion(label, node)
         # We should use the content location as we only replace the content and not the delimiters of the string
         loc = node.content_loc
@@ -593,15 +582,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          real_name: String,
-          incomplete_name: String,
-          range: Interface::Range,
-          entries: T::Array[RubyIndexer::Entry],
-          top_level: T::Boolean,
-        ).returns(Interface::CompletionItem)
-      end
+      #: (String real_name, String incomplete_name, Interface::Range range, Array[RubyIndexer::Entry] entries, bool top_level) -> Interface::CompletionItem
       def build_entry_completion(real_name, incomplete_name, range, entries, top_level)
         first_entry = T.must(entries.first)
         kind = case first_entry
@@ -690,7 +671,7 @@ module RubyLsp
       #   B
       # end
       # ```
-      sig { params(entry_name: String).returns(T::Boolean) }
+      #: (String entry_name) -> bool
       def top_level?(entry_name)
         nesting = @node_context.nesting
         nesting.length.downto(0) do |i|