ruby-lsp 0.17.6 → 0.17.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7299237468ae17d80028a1454903f58b1be4ff34428a6c8a538530b5caad54d1
-  data.tar.gz: 26351e5be1671219a9b3624076b2f50fb68c5838303fe1a021eecb39c4e3e9f1
+  metadata.gz: 671bab4fdbd77d1980781f55874d6cd448e1dcd11a6f534a176dfb00b098d2eb
+  data.tar.gz: bd12fd2ef58588b3b5386fec48c0f561140efff180988f1971b67f635f0e1042
 SHA512:
-  metadata.gz: 54cc76a3506a268398cfc51645a70300e2d14bda5b39c12274863270f70ed666b33bfebdf50dac8e013410e8ddba5645f4f435863af795d268710e0ccf9d8814
-  data.tar.gz: 95e52a4aa6f68785495f7435fe54cc395c062809ad3754703f808c68d2599bc34a619578bbb8453cb54de88a8312ac49eff8dd2e72a82bc04554c7b659c477cd
+  metadata.gz: f3a2a3115e1745ad7263b7e113ef13795f9a1ed1ee118128a9ab2aaad703b17551acbd929f820700e6650efb76421418a13a78270ac8d3aaff080edc46731aee
+  data.tar.gz: d29bb4d6c60727eef1a10905762a6d0c8946b7afc8aac6148ef970c8d752365f1577403497702f52a7211689cde7940b3d7cd1e1e0eb03d038e0dc6f7ceed738

data/VERSION

@@ -1 +1 @@
-0.17.6
+0.17.7

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -331,14 +331,17 @@ module RubyIndexer
       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

data/lib/ruby_indexer/test/index_test.rb

@@ -285,6 +285,43 @@ module RubyIndexer
       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

data/lib/ruby_lsp/document.rb

@@ -127,8 +127,18 @@ module RubyLsp
       parent = T.let(nil, T.nilable(Prism::Node))
       nesting_nodes = T.let(
         [],
-        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+        T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
       )
+
+      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -158,11 +168,8 @@ module RubyLsp
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
         case candidate
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting_nodes << candidate
-        when Prism::SingletonClassNode
-          nesting_nodes << candidate
-        when Prism::DefNode
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
+          Prism::LambdaNode
           nesting_nodes << candidate
         end
 
@@ -203,24 +210,7 @@ module RubyLsp
         end
       end
 
-      nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
-
-      nesting_nodes.each do |node|
-        case node
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting << node.constant_path.slice
-        when Prism::SingletonClassNode
-          nesting << "<Class:#{nesting.last}>"
-        when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<Class:#{nesting.last}>"
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
+      NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -69,7 +69,7 @@ module RubyLsp
       @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
 
       specified_linters = options.dig(:initializationOptions, :linters)
-      @linters = specified_linters || detect_linters(direct_dependencies)
+      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
       @test_library = detect_test_library(direct_dependencies)
       @has_type_checker = detect_typechecker(direct_dependencies)
 
@@ -127,10 +127,14 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
-    def detect_linters(dependencies)
+    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies, all_dependencies)
       linters = []
-      linters << "rubocop" if dependencies.any?(/^rubocop/)
+
+      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
+        linters << "rubocop"
+      end
+
       linters
     end
 

data/lib/ruby_lsp/listeners/completion.rb

@@ -277,6 +277,8 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
+        add_local_completions(node, name)
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
@@ -322,6 +324,31 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_local_completions(node, name)
+        return if @global_state.has_type_checker
+
+        # If the call node has a receiver, then it cannot possibly be a local variable
+        return if node.receiver
+
+        range = range_from_location(T.must(node.message_loc))
+
+        @node_context.locals_for_scope.each do |local|
+          local_name = local.to_s
+          next unless local_name.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: local_name,
+            filter_text: local_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: local_name),
+            kind: Constant::CompletionItemKind::VARIABLE,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
+      end
+
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         # We should use the content location as we only replace the content and not the delimiters of the string

data/lib/ruby_lsp/listeners/definition.rb

@@ -46,6 +46,8 @@ module RubyLsp
           :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 @@ module RubyLsp
         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 @@ 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(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

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::SuperNode,
+          Prism::ForwardingSuperNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -64,6 +66,8 @@ module RubyLsp
           :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 @@ module RubyLsp
         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 @@ module RubyLsp
         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)

data/lib/ruby_lsp/node_context.rb

@@ -23,22 +23,82 @@ module RubyLsp
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
-        nesting: T::Array[String],
+        nesting_nodes: T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
         call_node: T.nilable(Prism::CallNode),
-        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node, surrounding_method)
+    def initialize(node, parent, nesting_nodes, call_node)
       @node = node
       @parent = parent
-      @nesting = nesting
+      @nesting_nodes = nesting_nodes
       @call_node = call_node
-      @surrounding_method = surrounding_method
+
+      nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
+      @nesting = T.let(nesting, T::Array[String])
+      @surrounding_method = T.let(surrounding_method, T.nilable(String))
     end
 
     sig { returns(String) }
     def fully_qualified_name
       @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
     end
+
+    sig { returns(T::Array[Symbol]) }
+    def locals_for_scope
+      locals = []
+
+      @nesting_nodes.each do |node|
+        if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) || node.is_a?(Prism::SingletonClassNode) ||
+            node.is_a?(Prism::DefNode)
+          locals.clear
+        end
+
+        locals.concat(node.locals)
+      end
+
+      locals
+    end
+
+    private
+
+    sig do
+      params(nodes: T::Array[T.any(
+        Prism::ClassNode,
+        Prism::ModuleNode,
+        Prism::SingletonClassNode,
+        Prism::DefNode,
+        Prism::BlockNode,
+        Prism::LambdaNode,
+        Prism::ProgramNode,
+      )]).returns([T::Array[String], T.nilable(String)])
+    end
+    def handle_nesting_nodes(nodes)
+      nesting = []
+      surrounding_method = T.let(nil, T.nilable(String))
+
+      @nesting_nodes.each do |node|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting << node.constant_path.slice
+        when Prism::SingletonClassNode
+          nesting << "<Class:#{nesting.last}>"
+        when Prism::DefNode
+          surrounding_method = node.name.to_s
+          next unless node.receiver.is_a?(Prism::SelfNode)
+
+          nesting << "<Class:#{nesting.last}>"
+        end
+      end
+
+      [nesting, surrounding_method]
+    end
   end
 end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -38,6 +38,8 @@ module RubyLsp
 
       sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        return @item if @item.dig(:data, :skip_resolve)
+
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
         # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might

data/lib/ruby_lsp/requests/definition.rb

@@ -62,6 +62,8 @@ module RubyLsp
             Prism::InstanceVariableWriteNode,
             Prism::SymbolNode,
             Prism::StringNode,
+            Prism::SuperNode,
+            Prism::ForwardingSuperNode,
           ],
         )
 

data/lib/ruby_lsp/type_inferrer.rb

@@ -20,16 +20,9 @@ module RubyLsp
       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 @@ module RubyLsp
 
       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 @@ module RubyLsp
       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(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.6
+  version: 0.17.7
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol