ruby-lsp 0.23.11 → 0.23.13

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -4,19 +4,12 @@
 module RubyLsp
   module Listeners
     class FoldingRanges
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
-          comments: T::Array[Prism::Comment],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange] response_builder, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, comments, dispatcher)
         @response_builder = response_builder
-        @requires = T.let([], T::Array[Prism::CallNode])
+        @requires = [] #: Array[Prism::CallNode]
         @comments = comments
 
         dispatcher.register(
@@ -47,33 +40,33 @@ module RubyLsp
         )
       end
 
-      sig { void }
+      #: -> void
       def finalize_response!
         push_comment_ranges
         emit_requires_range
       end
 
-      sig { params(node: Prism::IfNode).void }
+      #: (Prism::IfNode node) -> void
       def on_if_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: Prism::InNode).void }
+      #: (Prism::InNode node) -> void
       def on_in_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: Prism::RescueNode).void }
+      #: (Prism::RescueNode node) -> void
       def on_rescue_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: Prism::WhenNode).void }
+      #: (Prism::WhenNode node) -> void
       def on_when_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: Prism::InterpolatedStringNode).void }
+      #: (Prism::InterpolatedStringNode node) -> void
       def on_interpolated_string_node_enter(node)
         opening_loc = node.opening_loc || node.location
         closing_loc = node.closing_loc || node.parts.last&.location || node.location
@@ -81,82 +74,82 @@ module RubyLsp
         add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
       end
 
-      sig { params(node: Prism::ArrayNode).void }
+      #: (Prism::ArrayNode node) -> void
       def on_array_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::BlockNode).void }
+      #: (Prism::BlockNode node) -> void
       def on_block_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::CaseNode).void }
+      #: (Prism::CaseNode node) -> void
       def on_case_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::CaseMatchNode).void }
+      #: (Prism::CaseMatchNode node) -> void
       def on_case_match_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::ForNode).void }
+      #: (Prism::ForNode node) -> void
       def on_for_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::HashNode).void }
+      #: (Prism::HashNode node) -> void
       def on_hash_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::SingletonClassNode).void }
+      #: (Prism::SingletonClassNode node) -> void
       def on_singleton_class_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::UnlessNode).void }
+      #: (Prism::UnlessNode node) -> void
       def on_unless_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::UntilNode).void }
+      #: (Prism::UntilNode node) -> void
       def on_until_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::WhileNode).void }
+      #: (Prism::WhileNode node) -> void
       def on_while_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::ElseNode).void }
+      #: (Prism::ElseNode node) -> void
       def on_else_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::EnsureNode).void }
+      #: (Prism::EnsureNode node) -> void
       def on_ensure_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::BeginNode).void }
+      #: (Prism::BeginNode node) -> void
       def on_begin_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         params = node.parameters
         parameter_loc = params&.location
@@ -171,7 +164,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
         # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
@@ -184,14 +177,14 @@ module RubyLsp
         add_lines_range(location.start_line, location.end_line - 1)
       end
 
-      sig { params(node: Prism::LambdaNode).void }
+      #: (Prism::LambdaNode node) -> void
       def on_lambda_node_enter(node)
         add_simple_range(node)
       end
 
       private
 
-      sig { void }
+      #: -> void
       def push_comment_ranges
         # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
         @comments.chunk_while do |this, other|
@@ -207,7 +200,7 @@ module RubyLsp
         end
       end
 
-      sig { void }
+      #: -> void
       def emit_requires_range
         if @requires.length > 1
           @response_builder << Interface::FoldingRange.new(
@@ -220,7 +213,7 @@ module RubyLsp
         @requires.clear
       end
 
-      sig { params(node: Prism::CallNode).returns(T::Boolean) }
+      #: (Prism::CallNode node) -> bool
       def require?(node)
         message = node.message
         return false unless message == "require" || message == "require_relative"
@@ -234,7 +227,7 @@ module RubyLsp
         arguments.length == 1 && arguments.first.is_a?(Prism::StringNode)
       end
 
-      sig { params(node: T.any(Prism::IfNode, Prism::InNode, Prism::RescueNode, Prism::WhenNode)).void }
+      #: ((Prism::IfNode | Prism::InNode | Prism::RescueNode | Prism::WhenNode) node) -> void
       def add_statements_range(node)
         statements = node.statements
         return unless statements
@@ -245,13 +238,13 @@ module RubyLsp
         add_lines_range(node.location.start_line, statement.location.end_line)
       end
 
-      sig { params(node: Prism::Node).void }
+      #: (Prism::Node node) -> void
       def add_simple_range(node)
         location = node.location
         add_lines_range(location.start_line, location.end_line - 1)
       end
 
-      sig { params(start_line: Integer, end_line: Integer).void }
+      #: (Integer start_line, Integer end_line) -> void
       def add_lines_range(start_line, end_line)
         emit_requires_range
         return if start_line >= end_line

data/lib/ruby_lsp/listeners/hover.rb

@@ -4,67 +4,51 @@
 module RubyLsp
   module Listeners
     class Hover
-      extend T::Sig
       include Requests::Support::Common
 
-      ALLOWED_TARGETS = T.let(
-        [
-          Prism::CallNode,
-          Prism::ConstantReadNode,
-          Prism::ConstantWriteNode,
-          Prism::ConstantPathNode,
-          Prism::GlobalVariableAndWriteNode,
-          Prism::GlobalVariableOperatorWriteNode,
-          Prism::GlobalVariableOrWriteNode,
-          Prism::GlobalVariableReadNode,
-          Prism::GlobalVariableTargetNode,
-          Prism::GlobalVariableWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode,
-          Prism::SymbolNode,
-          Prism::StringNode,
-          Prism::InterpolatedStringNode,
-          Prism::SuperNode,
-          Prism::ForwardingSuperNode,
-          Prism::YieldNode,
-          Prism::ClassVariableAndWriteNode,
-          Prism::ClassVariableOperatorWriteNode,
-          Prism::ClassVariableOrWriteNode,
-          Prism::ClassVariableReadNode,
-          Prism::ClassVariableTargetNode,
-          Prism::ClassVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      ALLOWED_REMOTE_PROVIDERS = T.let(
-        [
-          "https://github.com",
-          "https://gitlab.com",
-        ].freeze,
-        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
+      ALLOWED_TARGETS = [
+        Prism::CallNode,
+        Prism::ConstantReadNode,
+        Prism::ConstantWriteNode,
+        Prism::ConstantPathNode,
+        Prism::GlobalVariableAndWriteNode,
+        Prism::GlobalVariableOperatorWriteNode,
+        Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableReadNode,
+        Prism::GlobalVariableTargetNode,
+        Prism::GlobalVariableWriteNode,
+        Prism::InstanceVariableReadNode,
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableTargetNode,
+        Prism::InstanceVariableWriteNode,
+        Prism::SymbolNode,
+        Prism::StringNode,
+        Prism::InterpolatedStringNode,
+        Prism::SuperNode,
+        Prism::ForwardingSuperNode,
+        Prism::YieldNode,
+        Prism::ClassVariableAndWriteNode,
+        Prism::ClassVariableOperatorWriteNode,
+        Prism::ClassVariableOrWriteNode,
+        Prism::ClassVariableReadNode,
+        Prism::ClassVariableTargetNode,
+        Prism::ClassVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      ALLOWED_REMOTE_PROVIDERS = [
+        "https://github.com",
+        "https://gitlab.com",
+      ].freeze #: Array[String]
+
+      #: (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
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
+        @path = uri.to_standardized_path #: String?
         @node_context = node_context
         @sorbet_level = sorbet_level
 
@@ -100,17 +84,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 +104,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 +121,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 +136,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 +268,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 +280,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 +291,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 +314,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 +333,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 +343,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 +358,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 +373,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)
@@ -397,14 +381,11 @@ module RubyLsp
         spec = Gem::Specification.find_by_name(first_argument.content)
         return unless spec
 
-        info = T.let(
-          [
-            spec.description,
-            spec.summary,
-            "This rubygem does not have a description or summary.",
-          ].find { |text| !text.nil? && !text.empty? },
-          String,
-        )
+        info = [
+          spec.description,
+          spec.summary,
+          "This rubygem does not have a description or summary.",
+        ].find { |text| !text.nil? && !text.empty? } #: String
 
         # Remove leading whitespace if a heredoc was used for the summary or description
         info = info.gsub(/^ +/, "")

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)
+      RESCUE_STRING_LENGTH = "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)