ruby-lsp 0.23.11 → 0.26.6

data/lib/ruby_lsp/listeners/definition.rb

@@ -4,30 +4,16 @@
 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, Symbol language_id, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, 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
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @language_id = language_id
         @uri = uri
         @node_context = node_context
@@ -64,10 +50,10 @@ 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)
+        return if @sorbet_level.true_or_higher? && self_receiver?(node)
 
         message = node.message
         return unless message
@@ -76,36 +62,38 @@ module RubyLsp
 
         # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
         # treating method calls' type as `nil` will allow users to get some completion support first
-        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type&.name == "Object"
+        if @language_id == :erb && inferrer_receiver_type&.name == "Object"
           inferrer_receiver_type = nil
         end
 
         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
-
-        name = enclosing_call.name
-        return unless name == :require || name == :require_relative
-
-        handle_require_definition(node, name)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :require, :require_relative
+            handle_require_definition(node, name)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.content }
+          end
+        end
       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
-
-        name = enclosing_call.name
-        return unless name == :autoload
-
-        handle_autoload_definition(enclosing_call)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :autoload
+            handle_autoload_definition(enclosing_call)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.unescaped }
+          end
+        end
       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 +104,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 +112,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,112 +120,130 @@ 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 }
+      #: (Prism::Node node) { (Prism::CallNode, Symbol) -> void } -> void
+      def with_enclosing_call(node, &block)
+        enclosing_call = @node_context.call_node
+        return unless enclosing_call
+
+        block.call(enclosing_call, enclosing_call.name)
+      end
+
+      #: (Prism::CallNode enclosing_call, Prism::Node node) { -> String } -> void
+      def handle_send_or_public_send_definition(enclosing_call, node, &block)
+        first_argument = enclosing_call.arguments&.arguments&.first
+        return unless first_argument.eql?(node)
+
+        method_name = block.call
+
+        handle_method_definition(method_name, nil)
+      end
+
+      #: -> 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)
+        return if @sorbet_level.true_or_higher?
 
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
@@ -249,7 +255,7 @@ module RubyLsp
         )
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def handle_global_variable_definition(name)
         entries = @index[name]
 
@@ -268,7 +274,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,11 +292,11 @@ 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
-        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+        return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -313,7 +319,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)
@@ -331,7 +337,7 @@ module RubyLsp
         methods.each do |target_method|
           uri = target_method.uri
           full_path = uri.full_path
-          next if sorbet_level_true_or_higher?(@sorbet_level) && (!full_path || not_in_dependencies?(full_path))
+          next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,
@@ -341,7 +347,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 +384,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,14 +395,14 @@ 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
 
         # We should only allow jumping to the definition of private constants if the constant is defined in the same
         # namespace as the reference
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
         return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
 
         entries.each do |entry|
@@ -406,7 +412,7 @@ module RubyLsp
           uri = entry.uri
           full_path = uri.full_path
 
-          if @sorbet_level != RubyDocument::SorbetLevel::Ignore && (!full_path || not_in_dependencies?(full_path))
+          if !@sorbet_level.ignore? && (!full_path || not_in_dependencies?(full_path))
             next
           end