ruby-lsp 0.23.10 → 0.23.12

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|

data/lib/ruby_lsp/listeners/definition.rb

@@ -4,25 +4,11 @@
 module RubyLsp
   module Listeners
     class Definition
-      extend T::Sig
       include Requests::Support::Common
 
       MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 10
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location,
-            Interface::LocationLink,
-          )],
-          global_state: GlobalState,
-          language_id: Document::LanguageId,
-          uri: URI::Generic,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, GlobalState global_state, Document::LanguageId language_id, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
@@ -64,7 +50,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         # Sorbet can handle go to definition for methods invoked on self on typed true or higher
         return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
@@ -83,7 +69,7 @@ module RubyLsp
         handle_method_definition(message, inferrer_receiver_type)
       end
 
-      sig { params(node: Prism::StringNode).void }
+      #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         enclosing_call = @node_context.call_node
         return unless enclosing_call
@@ -94,7 +80,7 @@ module RubyLsp
         handle_require_definition(node, name)
       end
 
-      sig { params(node: Prism::SymbolNode).void }
+      #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
         enclosing_call = @node_context.call_node
         return unless enclosing_call
@@ -105,7 +91,7 @@ module RubyLsp
         handle_autoload_definition(enclosing_call)
       end
 
-      sig { params(node: Prism::BlockArgumentNode).void }
+      #: (Prism::BlockArgumentNode node) -> void
       def on_block_argument_node_enter(node)
         expression = node.expression
         return unless expression.is_a?(Prism::SymbolNode)
@@ -116,7 +102,7 @@ module RubyLsp
         handle_method_definition(value, nil)
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
+      #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -124,7 +110,7 @@ module RubyLsp
         find_in_index(name)
       end
 
-      sig { params(node: Prism::ConstantReadNode).void }
+      #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -132,109 +118,109 @@ module RubyLsp
         find_in_index(name)
       end
 
-      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      #: (Prism::GlobalVariableAndWriteNode node) -> void
       def on_global_variable_and_write_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      #: (Prism::GlobalVariableOperatorWriteNode node) -> void
       def on_global_variable_operator_write_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      #: (Prism::GlobalVariableOrWriteNode node) -> void
       def on_global_variable_or_write_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::GlobalVariableReadNode).void }
+      #: (Prism::GlobalVariableReadNode node) -> void
       def on_global_variable_read_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      #: (Prism::GlobalVariableTargetNode node) -> void
       def on_global_variable_target_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      #: (Prism::GlobalVariableWriteNode node) -> void
       def on_global_variable_write_node_enter(node)
         handle_global_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableReadNode).void }
+      #: (Prism::InstanceVariableReadNode node) -> void
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableWriteNode).void }
+      #: (Prism::InstanceVariableWriteNode node) -> void
       def on_instance_variable_write_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      #: (Prism::InstanceVariableAndWriteNode node) -> void
       def on_instance_variable_and_write_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      #: (Prism::InstanceVariableOperatorWriteNode node) -> void
       def on_instance_variable_operator_write_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      #: (Prism::InstanceVariableOrWriteNode node) -> void
       def on_instance_variable_or_write_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      #: (Prism::InstanceVariableTargetNode node) -> void
       def on_instance_variable_target_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::SuperNode).void }
+      #: (Prism::SuperNode node) -> void
       def on_super_node_enter(node)
         handle_super_node_definition
       end
 
-      sig { params(node: Prism::ForwardingSuperNode).void }
+      #: (Prism::ForwardingSuperNode node) -> void
       def on_forwarding_super_node_enter(node)
         handle_super_node_definition
       end
 
-      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      #: (Prism::ClassVariableOperatorWriteNode node) -> void
       def on_class_variable_operator_write_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      #: (Prism::ClassVariableOrWriteNode node) -> void
       def on_class_variable_or_write_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::ClassVariableTargetNode).void }
+      #: (Prism::ClassVariableTargetNode node) -> void
       def on_class_variable_target_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::ClassVariableReadNode).void }
+      #: (Prism::ClassVariableReadNode node) -> void
       def on_class_variable_read_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
-      sig { params(node: Prism::ClassVariableWriteNode).void }
+      #: (Prism::ClassVariableWriteNode node) -> void
       def on_class_variable_write_node_enter(node)
         handle_class_variable_definition(node.name.to_s)
       end
 
       private
 
-      sig { void }
+      #: -> void
       def handle_super_node_definition
         # Sorbet can handle super hover on typed true or higher
         return if sorbet_level_true_or_higher?(@sorbet_level)
@@ -249,7 +235,7 @@ module RubyLsp
         )
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def handle_global_variable_definition(name)
         entries = @index[name]
 
@@ -268,7 +254,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def handle_class_variable_definition(name)
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -286,7 +272,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).void }
+      #: (String name) -> void
       def handle_instance_variable_definition(name)
         # 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
@@ -313,7 +299,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(message: String, receiver_type: T.nilable(TypeInferrer::Type), inherited_only: T::Boolean).void }
+      #: (String message, TypeInferrer::Type? receiver_type, ?inherited_only: bool) -> void
       def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
           @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
@@ -341,7 +327,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::StringNode, message: Symbol).void }
+      #: (Prism::StringNode node, Symbol message) -> void
       def handle_require_definition(node, message)
         case message
         when :require
@@ -378,7 +364,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_autoload_definition(node)
         argument = node.arguments&.arguments&.first
         return unless argument.is_a?(Prism::SymbolNode)
@@ -389,7 +375,7 @@ module RubyLsp
         find_in_index(constant_name)
       end
 
-      sig { params(value: String).void }
+      #: (String value) -> void
       def find_in_index(value)
         entries = @index.resolve(value, @node_context.nesting)
         return unless entries