Add super support for definition and hover (#2245)

* Infer receiver type for super calls

* Allow resolving only inherited methods

* Support super in definition

* Support super in hover

Author: vinistock

lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -331,14 +331,17 @@ def follow_aliased_namespace(name, seen_names = [])
       params(
         method_name: String,
         receiver_name: String,
+        inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name)
+    def resolve_method(method_name, receiver_name, inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
       ancestors = linearized_ancestors_of(receiver_name.delete_prefix("::"))
       ancestors.each do |ancestor|
+        next if inherited_only && ancestor == receiver_name
+
         found = method_entries.filter_map do |entry|
           case entry
           when Entry::Member, Entry::MethodAlias

lib/ruby_indexer/test/index_test.rb

@@ -285,6 +285,43 @@ def bar; end
       assert_includes(second_entry.comments, "Hello from second `bar`")
     end
 
+    def test_resolve_method_inherited_only
+      index(<<~RUBY)
+        class Bar
+          def baz; end
+        end
+
+        class Foo < Bar
+          def baz; end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo", inherited_only: true).first)
+
+      assert_equal("Bar", T.must(entry.owner).name)
+    end
+
+    def test_resolve_method_inherited_only_for_prepended_module
+      index(<<~RUBY)
+        module Bar
+          def baz
+            super
+          end
+        end
+
+        class Foo
+          prepend Bar
+
+          def baz; end
+        end
+      RUBY
+
+      # This test is just to document the fact that we don't yet support resolving inherited methods for modules that
+      # are prepended. The only way to support this is to find all namespaces that have the module a subtype, so that we
+      # can show the results for everywhere the module has been prepended.
+      assert_nil(@index.resolve_method("baz", "Bar", inherited_only: true))
+    end
+
     def test_prefix_search_for_methods
       index(<<~RUBY)
         module Foo

lib/ruby_lsp/listeners/definition.rb

@@ -46,6 +46,8 @@ def initialize(response_builder, global_state, language_id, uri, node_context, d
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
           :on_string_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -133,8 +135,30 @@ def on_instance_variable_target_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_definition
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_definition
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_definition
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_definition(
+          surrounding_method,
+          @type_inferrer.infer_receiver_type(@node_context),
+          inherited_only: true,
+        )
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
         type = @type_inferrer.infer_receiver_type(@node_context)
@@ -158,10 +182,10 @@ def handle_instance_variable_definition(name)
         # 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(String)).void }
-      def handle_method_definition(message, receiver_type)
+      sig { params(message: String, receiver_type: T.nilable(String), inherited_only: T::Boolean).void }
+      def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
-          @index.resolve_method(message, receiver_type)
+          @index.resolve_method(message, receiver_type, inherited_only: inherited_only)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming

lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,8 @@ class Hover
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::SuperNode,
+          Prism::ForwardingSuperNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -64,6 +66,8 @@ def initialize(response_builder, global_state, uri, node_context, dispatcher, ty
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -106,17 +110,7 @@ def on_call_node_enter(node)
         message = node.message
         return unless message
 
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        methods = @index.resolve_method(message, type)
-        return unless methods
-
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
-
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
-          @response_builder.push(content, category: category)
-        end
+        handle_method_hover(message)
       end
 
       sig { params(node: Prism::InstanceVariableReadNode).void }
@@ -149,8 +143,41 @@ def on_instance_variable_target_node_enter(node)
         handle_instance_variable_hover(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_hover
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_hover
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_hover
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_hover(surrounding_method, inherited_only: true)
+      end
+
+      sig { params(message: String, inherited_only: T::Boolean).void }
+      def handle_method_hover(message, inherited_only: false)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type, inherited_only: inherited_only)
+        return unless methods
+
+        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
         type = @type_inferrer.infer_receiver_type(@node_context)

lib/ruby_lsp/requests/definition.rb

@@ -62,6 +62,8 @@ def initialize(document, global_state, position, dispatcher, typechecker_enabled
             Prism::InstanceVariableWriteNode,
             Prism::SymbolNode,
             Prism::StringNode,
+            Prism::SuperNode,
+            Prism::ForwardingSuperNode,
           ],
         )
 

lib/ruby_lsp/type_inferrer.rb

@@ -20,16 +20,9 @@ def infer_receiver_type(node_context)
       when Prism::CallNode
         infer_receiver_for_call_node(node, node_context)
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
-        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode
-        nesting = node_context.nesting
-        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
-        # inherits from Object
-        return "Object" if nesting.empty?
-
-        fully_qualified_name = node_context.fully_qualified_name
-        return fully_qualified_name if node_context.surrounding_method
-
-        "#{fully_qualified_name}::<Class:#{nesting.last}>"
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
+        Prism::SuperNode, Prism::ForwardingSuperNode
+        self_receiver_handling(node_context)
       end
     end
 
@@ -41,15 +34,7 @@ def infer_receiver_for_call_node(node, node_context)
 
       case receiver
       when Prism::SelfNode, nil
-        nesting = node_context.nesting
-        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
-        # inherits from Object
-        return "Object" if nesting.empty?
-        return node_context.fully_qualified_name if node_context.surrounding_method
-
-        # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-        # context
-        "#{nesting.join("::")}::<Class:#{nesting.last}>"
+        self_receiver_handling(node_context)
       when Prism::ConstantPathNode, Prism::ConstantReadNode
         # When the receiver is a constant reference, we have to try to resolve it to figure out the right
         # receiver. But since the invocation is directly on the constant, that's the singleton context of that
@@ -68,6 +53,19 @@ def infer_receiver_for_call_node(node, node_context)
       end
     end
 
+    sig { params(node_context: NodeContext).returns(String) }
+    def self_receiver_handling(node_context)
+      nesting = node_context.nesting
+      # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+      # inherits from Object
+      return "Object" if nesting.empty?
+      return node_context.fully_qualified_name if node_context.surrounding_method
+
+      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+      # context
+      "#{nesting.join("::")}::<Class:#{nesting.last}>"
+    end
+
     sig do
       params(
         node: T.any(

test/requests/definition_expectations_test.rb

@@ -741,6 +741,45 @@ def do_something
     end
   end
 
+  def test_definition_for_super_calls
+    source = <<~RUBY
+      class Parent
+        def foo; end
+        def bar; end
+      end
+
+      class Child < Parent
+        def foo(a)
+          super()
+        end
+
+        def bar
+          super
+        end
+      end
+    RUBY
+
+    with_server(source) do |server, uri|
+      server.process_message(
+        id: 1,
+        method: "textDocument/definition",
+        params: { textDocument: { uri: uri }, position: { character: 4, line: 7 } },
+      )
+
+      response = server.pop_response.response
+      assert_equal(1, response[0].target_range.start.line)
+
+      server.process_message(
+        id: 1,
+        method: "textDocument/definition",
+        params: { textDocument: { uri: uri }, position: { character: 4, line: 11 } },
+      )
+
+      response = server.pop_response.response
+      assert_equal(2, response[0].target_range.start.line)
+    end
+  end
+
   private
 
   def create_definition_addon

test/requests/hover_expectations_test.rb

@@ -574,6 +574,47 @@ def do_something
     end
   end
 
+  def test_hover_for_super_calls
+    source = <<~RUBY
+      class Parent
+        # Foo
+        def foo; end
+        # Bar
+        def bar; end
+      end
+
+      class Child < Parent
+        def foo(a)
+          super()
+        end
+
+        def bar
+          super
+        end
+      end
+    RUBY
+
+    with_server(source) do |server, uri|
+      server.process_message(
+        id: 1,
+        method: "textDocument/hover",
+        params: { textDocument: { uri: uri }, position: { character: 4, line: 9 } },
+      )
+
+      contents = server.pop_response.response.contents.value
+      assert_match("Foo", contents)
+
+      server.process_message(
+        id: 1,
+        method: "textDocument/hover",
+        params: { textDocument: { uri: uri }, position: { character: 4, line: 13 } },
+      )
+
+      contents = server.pop_response.response.contents.value
+      assert_match("Bar", contents)
+    end
+  end
+
   private
 
   def create_hover_addon

test/type_inferrer_test.rb

@@ -172,6 +172,30 @@ def test_infer_top_level_instance_variables
       assert_equal("Object", @type_inferrer.infer_receiver_type(node_context))
     end
 
+    def test_infer_forwading_super_receiver
+      node_context = index_and_locate(<<~RUBY, { line: 2, character: 4 })
+        class Foo < Bar
+          def initialize
+            super
+          end
+        end
+      RUBY
+
+      assert_equal("Foo", @type_inferrer.infer_receiver_type(node_context))
+    end
+
+    def test_infer_super_receiver
+      node_context = index_and_locate(<<~RUBY, { line: 2, character: 4 })
+        class Foo < Bar
+          def initialize(a, b, c)
+            super()
+          end
+        end
+      RUBY
+
+      assert_equal("Foo", @type_inferrer.infer_receiver_type(node_context))
+    end
+
     private
 
     def index_and_locate(source, position)