ruby-lsp 0.23.11 → 0.23.17

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, 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,19 +84,19 @@ 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
+        return unless @sorbet_level.ignore?
 
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -120,16 +104,16 @@ 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
+        return unless @sorbet_level.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
+        return unless @sorbet_level.ignore?
 
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -137,14 +121,14 @@ 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)
           return
         end
 
-        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+        return if @sorbet_level.true_or_higher? && self_receiver?(node)
 
         message = node.message
         return unless message
@@ -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,10 +280,10 @@ 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)
+        return if @sorbet_level.true_or_higher?
 
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
@@ -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
@@ -315,7 +299,7 @@ module RubyLsp
         methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
-        first_method = T.must(methods.first)
+        first_method = methods.first #: as !nil
 
         title = "#{message}#{first_method.decorated_parameters}"
         title << first_method.formatted_signatures
@@ -330,11 +314,11 @@ 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
-        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+        return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -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,22 +358,23 @@ 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
 
         # We should only show hover for private constants if the constant is defined in the same namespace as the
         # reference
-        first_entry = T.must(entries.first)
-        return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{name}"
+        first_entry = entries.first #: as !nil
+        full_name = first_entry.name
+        return if first_entry.private? && full_name != "#{@node_context.fully_qualified_name}::#{name}"
 
-        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+        categorized_markdown_from_index_entries(full_name, entries).each do |category, content|
           @response_builder.push(content, category: category)
         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 +382,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)