ruby-lsp 0.23.11 → 0.23.12

data/lib/ruby_lsp/listeners/hover.rb

@@ -4,7 +4,6 @@
 module RubyLsp
   module Listeners
     class Hover
-      extend T::Sig
       include Requests::Support::Common
 
       ALLOWED_TARGETS = T.let(
@@ -49,16 +48,7 @@ module RubyLsp
         T::Array[String],
       )
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::Hover,
-          global_state: GlobalState,
-          uri: URI::Generic,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
@@ -100,17 +90,17 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::StringNode).void }
+      #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         generate_heredoc_hover(node)
       end
 
-      sig { params(node: Prism::InterpolatedStringNode).void }
+      #: (Prism::InterpolatedStringNode node) -> void
       def on_interpolated_string_node_enter(node)
         generate_heredoc_hover(node)
       end
 
-      sig { params(node: Prism::ConstantReadNode).void }
+      #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
@@ -120,14 +110,14 @@ module RubyLsp
         generate_hover(name, node.location)
       end
 
-      sig { params(node: Prism::ConstantWriteNode).void }
+      #: (Prism::ConstantWriteNode node) -> void
       def on_constant_write_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
+      #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
@@ -137,7 +127,7 @@ module RubyLsp
         generate_hover(name, node.location)
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         if @path && File.basename(@path) == GEMFILE_NAME && node.name == :gem
           generate_gem_hover(node)
@@ -152,114 +142,114 @@ module RubyLsp
         handle_method_hover(message)
       end
 
-      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      #: (Prism::GlobalVariableAndWriteNode node) -> void
       def on_global_variable_and_write_node_enter(node)
         handle_global_variable_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(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_hover(node.name.to_s)
       end
 
-      sig { params(node: Prism::SuperNode).void }
+      #: (Prism::SuperNode node) -> void
       def on_super_node_enter(node)
         handle_super_node_hover
       end
 
-      sig { params(node: Prism::ForwardingSuperNode).void }
+      #: (Prism::ForwardingSuperNode node) -> void
       def on_forwarding_super_node_enter(node)
         handle_super_node_hover
       end
 
-      sig { params(node: Prism::YieldNode).void }
+      #: (Prism::YieldNode node) -> void
       def on_yield_node_enter(node)
         handle_keyword_documentation(node.keyword)
       end
 
-      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
         handle_class_variable_hover(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_hover(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_hover(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_hover(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_hover(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_hover(node.name.to_s)
       end
 
       private
 
-      sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
+      #: ((Prism::InterpolatedStringNode | Prism::StringNode) node) -> void
       def generate_heredoc_hover(node)
         return unless node.heredoc?
 
@@ -284,7 +274,7 @@ module RubyLsp
         end
       end
 
-      sig { params(keyword: String).void }
+      #: (String keyword) -> void
       def handle_keyword_documentation(keyword)
         content = KEYWORD_DOCS[keyword]
         return unless content
@@ -296,7 +286,7 @@ module RubyLsp
         @response_builder.push(content, category: :documentation)
       end
 
-      sig { void }
+      #: -> void
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher
         return if sorbet_level_true_or_higher?(@sorbet_level)
@@ -307,7 +297,7 @@ module RubyLsp
         handle_method_hover(surrounding_method, inherited_only: true)
       end
 
-      sig { params(message: String, inherited_only: T::Boolean).void }
+      #: (String message, ?inherited_only: bool) -> void
       def handle_method_hover(message, inherited_only: false)
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -330,7 +320,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def handle_instance_variable_hover(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
@@ -349,7 +339,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_global_variable_hover(name)
         entries = @index[name]
         return unless entries
@@ -359,7 +349,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def handle_class_variable_hover(name)
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -374,7 +364,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 generate_hover(name, location)
         entries = @index.resolve(name, @node_context.nesting)
         return unless entries
@@ -389,7 +379,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def generate_gem_hover(node)
         first_argument = node.arguments&.arguments&.first
         return unless first_argument.is_a?(Prism::StringNode)

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -4,18 +4,11 @@
 module RubyLsp
   module Listeners
     class InlayHints
-      extend T::Sig
       include Requests::Support::Common
 
       RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-          hints_configuration: RequestConfig,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint] response_builder, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, hints_configuration, dispatcher)
         @response_builder = response_builder
         @hints_configuration = hints_configuration
@@ -23,7 +16,7 @@ module RubyLsp
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
-      sig { params(node: Prism::RescueNode).void }
+      #: (Prism::RescueNode node) -> void
       def on_rescue_node_enter(node)
         return unless @hints_configuration.enabled?(:implicitRescue)
         return unless node.exceptions.empty?
@@ -38,7 +31,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
+      #: (Prism::ImplicitNode node) -> void
       def on_implicit_node_enter(node)
         return unless @hints_configuration.enabled?(:implicitHashValue)
 

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -5,7 +5,6 @@ module RubyLsp
   module Listeners
     class SemanticHighlighting
       include Requests::Support::Common
-      extend T::Sig
 
       SPECIAL_RUBY_METHODS = T.let(
         [
@@ -18,12 +17,7 @@ module RubyLsp
         T::Array[String],
       )
 
-      sig do
-        params(
-          dispatcher: Prism::Dispatcher,
-          response_builder: ResponseBuilders::SemanticHighlighting,
-        ).void
-      end
+      #: (Prism::Dispatcher dispatcher, ResponseBuilders::SemanticHighlighting response_builder) -> void
       def initialize(dispatcher, response_builder)
         @response_builder = response_builder
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
@@ -62,7 +56,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return if @inside_implicit_node
 
@@ -85,7 +79,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::MatchWriteNode).void }
+      #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_enter(node)
         call = node.call
 
@@ -95,86 +89,86 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::MatchWriteNode).void }
+      #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_leave(node)
         @inside_regex_capture = true if node.call.message == "=~"
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         @current_scope = Scope.new(@current_scope)
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
         @current_scope = T.must(@current_scope.parent)
       end
 
-      sig { params(node: Prism::BlockNode).void }
+      #: (Prism::BlockNode node) -> void
       def on_block_node_enter(node)
         @current_scope = Scope.new(@current_scope)
       end
 
-      sig { params(node: Prism::BlockNode).void }
+      #: (Prism::BlockNode node) -> void
       def on_block_node_leave(node)
         @current_scope = T.must(@current_scope.parent)
       end
 
-      sig { params(node: Prism::BlockLocalVariableNode).void }
+      #: (Prism::BlockLocalVariableNode node) -> void
       def on_block_local_variable_node_enter(node)
         @response_builder.add_token(node.location, :variable)
       end
 
-      sig { params(node: Prism::BlockParameterNode).void }
+      #: (Prism::BlockParameterNode node) -> void
       def on_block_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::RequiredKeywordParameterNode).void }
+      #: (Prism::RequiredKeywordParameterNode node) -> void
       def on_required_keyword_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::OptionalKeywordParameterNode).void }
+      #: (Prism::OptionalKeywordParameterNode node) -> void
       def on_optional_keyword_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::KeywordRestParameterNode).void }
+      #: (Prism::KeywordRestParameterNode node) -> void
       def on_keyword_rest_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::OptionalParameterNode).void }
+      #: (Prism::OptionalParameterNode node) -> void
       def on_optional_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::RequiredParameterNode).void }
+      #: (Prism::RequiredParameterNode node) -> void
       def on_required_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::RestParameterNode).void }
+      #: (Prism::RestParameterNode node) -> void
       def on_rest_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::SelfNode).void }
+      #: (Prism::SelfNode node) -> void
       def on_self_node_enter(node)
         @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
-      sig { params(node: Prism::LocalVariableWriteNode).void }
+      #: (Prism::LocalVariableWriteNode node) -> void
       def on_local_variable_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableReadNode).void }
+      #: (Prism::LocalVariableReadNode node) -> void
       def on_local_variable_read_node_enter(node)
         return if @inside_implicit_node
 
@@ -188,25 +182,25 @@ module RubyLsp
         @response_builder.add_token(node.location, local&.type || :variable)
       end
 
-      sig { params(node: Prism::LocalVariableAndWriteNode).void }
+      #: (Prism::LocalVariableAndWriteNode node) -> void
       def on_local_variable_and_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      #: (Prism::LocalVariableOperatorWriteNode node) -> void
       def on_local_variable_operator_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      #: (Prism::LocalVariableOrWriteNode node) -> void
       def on_local_variable_or_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableTargetNode).void }
+      #: (Prism::LocalVariableTargetNode node) -> void
       def on_local_variable_target_node_enter(node)
         # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.
         # Unfortunately, if the regex contains a backslash, the location will be incorrect and we'll end up highlighting
@@ -218,7 +212,7 @@ module RubyLsp
         @response_builder.add_token(node.location, local&.type || :variable)
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         constant_path = node.constant_path
 
@@ -257,7 +251,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         constant_path = node.constant_path
 
@@ -278,12 +272,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
+      #: (Prism::ImplicitNode node) -> void
       def on_implicit_node_enter(node)
         @inside_implicit_node = true
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
+      #: (Prism::ImplicitNode node) -> void
       def on_implicit_node_leave(node)
         @inside_implicit_node = false
       end
@@ -292,12 +286,12 @@ module RubyLsp
 
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that
       # highlighting, so we avoid making a semantic token for it.
-      sig { params(method_name: String).returns(T::Boolean) }
+      #: (String method_name) -> bool
       def special_method?(method_name)
         SPECIAL_RUBY_METHODS.include?(method_name)
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def process_regexp_locals(node)
         receiver = node.receiver
 

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -4,18 +4,9 @@
 module RubyLsp
   module Listeners
     class SignatureHelp
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::SignatureHelp,
-          global_state: GlobalState,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: (ResponseBuilders::SignatureHelp response_builder, GlobalState global_state, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)
         @sorbet_level = sorbet_level
         @response_builder = response_builder
@@ -26,7 +17,7 @@ module RubyLsp
         dispatcher.register(self, :on_call_node_enter)
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return if sorbet_level_true_or_higher?(@sorbet_level)
 
@@ -67,9 +58,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(node: Prism::CallNode, signatures: T::Array[RubyIndexer::Entry::Signature]).returns([Integer, Integer])
-      end
+      #: (Prism::CallNode node, Array[RubyIndexer::Entry::Signature] signatures) -> [Integer, Integer]
       def determine_active_signature_and_parameter(node, signatures)
         arguments_node = node.arguments
         arguments = arguments_node&.arguments || []
@@ -93,15 +82,7 @@ module RubyLsp
         [active_sig_index, active_parameter]
       end
 
-      sig do
-        params(
-          signatures: T::Array[RubyIndexer::Entry::Signature],
-          method_name: String,
-          methods: T::Array[RubyIndexer::Entry],
-          title: String,
-          extra_links: T.nilable(String),
-        ).returns(T::Array[Interface::SignatureInformation])
-      end
+      #: (Array[RubyIndexer::Entry::Signature] signatures, String method_name, Array[RubyIndexer::Entry] methods, String title, String? extra_links) -> Array[Interface::SignatureInformation]
       def generate_signatures(signatures, method_name, methods, title, extra_links)
         signatures.map do |signature|
           Interface::SignatureInformation.new(