ruby-lsp 0.23.22 → 0.23.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48c7e1cdc0e7f0a31cbc69002bf6a6c3dea0779272757ee40ae90e4199199446
-  data.tar.gz: 1cd0d4a426ed4b1c44540e9e3344f73623f0ea0193374cab8faa727528474bf2
+  metadata.gz: f36abe0931e1e5dede4e640d28315481026b16a5087021dcf8567dc97a1b7e2f
+  data.tar.gz: 5f7f3213e48ce66c7af5e67444ac6031d68269fe938c540c5b86b9c193a3c8c3
 SHA512:
-  metadata.gz: ac87c3a6dcc52b2696076d9793b42f03f56a4e0fbe258cc20f09502bbb289f91acccb3593ebfd36d61b5eeb0ec0bc3ab697acc332b61889fd256db2600029eca
-  data.tar.gz: be146b667f656ddb1103756a4cf79bd294981fa5f3d0cebc38e44498168799b14941c1768e9f030e80d4f4f7e8c4e4b0107e9cbaf694184ddc037824a05a2f1f
+  metadata.gz: 5242bc7d2fa9a17e49b0196161af27aaf99f57f45d1c5c07017c07e6ea5b0b572982fb1880020d727aa3db3c634a0336c811dcc874ff7cd507004fdb64ce560b
+  data.tar.gz: 13c106377644314b1854aa8cb0a3a6401c071ebc089a7aaa045b02503bc73569d3cda3e99b0897ebf6726606d66832dd652fb9aff171d68d95cf7374482912b9

data/VERSION

@@ -1 +1 @@
-0.23.22
+0.23.24

data/exe/ruby-lsp-launcher

@@ -83,8 +83,13 @@ begin
     # This Marshal load can only happen after requiring Bundler because it will load a custom error class from Bundler
     # itself. If we try to load before requiring, the class will not be defined and loading will fail
     error_path = File.join(".ruby-lsp", "install_error")
-    install_error = if File.exist?(error_path)
-      Marshal.load(File.read(error_path))
+    install_error = begin
+      Marshal.load(File.read(error_path)) if File.exist?(error_path)
+    rescue ArgumentError
+      # The class we tried to load is not defined. This might happen when the user upgrades Bundler and new error
+      # classes are introduced or removed
+      File.delete(error_path)
+      nil
     end
 
     Bundler.setup

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -254,7 +254,7 @@ module RubyIndexer
       case message
       when :private_constant
         handle_private_constant(node)
-      when :attr_reader
+      when :attr_reader, :attr
         handle_attribute(node, reader: true, writer: false)
       when :attr_writer
         handle_attribute(node, reader: false, writer: true)

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -2,11 +2,8 @@
 # frozen_string_literal: true
 
 module RubyIndexer
+  # @abstract
   class Enhancement
-    extend T::Helpers
-
-    abstract!
-
     @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -98,11 +98,8 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class ModuleOperation
-      extend T::Helpers
-
-      abstract!
-
       #: String
       attr_reader :module_name
 
@@ -115,11 +112,8 @@ module RubyIndexer
     class Include < ModuleOperation; end
     class Prepend < ModuleOperation; end
 
+    # @abstract
     class Namespace < Entry
-      extend T::Helpers
-
-      abstract!
-
       #: Array[String]
       attr_reader :nesting
 
@@ -191,11 +185,8 @@ module RubyIndexer
     class Constant < Entry
     end
 
+    # @abstract
     class Parameter
-      extend T::Helpers
-
-      abstract!
-
       # Name includes just the name of the parameter, excluding symbols like splats
       #: Symbol
       attr_reader :name
@@ -289,12 +280,8 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class Member < Entry
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Entry::Namespace?
       attr_reader :owner
 
@@ -305,7 +292,8 @@ module RubyIndexer
         @owner = owner
       end
 
-      sig { abstract.returns(T::Array[Entry::Signature]) }
+      # @abstract
+      #: -> Array[Signature]
       def signatures; end
 
       #: -> String

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

@@ -818,11 +818,22 @@ module RubyIndexer
     )
       # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
       # from two different classes in different files, we simply ignore it
-      superclass = if singleton_levels > 0
-        self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-      else
-        namespace_entries.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-      end #: as Entry::Class?
+      possible_parents = singleton_levels > 0 ? self[attached_class_name] : namespace_entries
+      superclass = nil #: Entry::Class?
+
+      possible_parents&.each do |n|
+        # Ignore non class entries
+        next unless n.is_a?(Entry::Class)
+
+        parent_class = n.parent_class
+        next unless parent_class
+
+        # Always set the superclass, but break early if we found one that isn't `::Object` (meaning we found an explicit
+        # parent class and not the implicit default). Note that when setting different parents to the same class, which
+        # is invalid, we pick whatever is the first one we find
+        superclass = n
+        break if parent_class != "::Object"
+      end
 
       if superclass
         # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -3,11 +3,8 @@
 
 module RubyIndexer
   class ReferenceFinder
-    class Target
-      extend T::Helpers
-
-      abstract!
-    end
+    # @abstract
+    class Target; end
 
     class ConstTarget < Target
       #: String
@@ -35,10 +32,14 @@ module RubyIndexer
       #: String
       attr_reader :name
 
-      #: (String name) -> void
-      def initialize(name)
+      #: Array[String]
+      attr_reader :owner_ancestors
+
+      #: (String name, Array[String] owner_ancestors) -> void
+      def initialize(name, owner_ancestors)
         super()
         @name = name
+        @owner_ancestors = owner_ancestors
       end
     end
 
@@ -325,7 +326,10 @@ module RubyIndexer
     def collect_instance_variable_references(name, location, declaration)
       return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
 
-      @references << Reference.new(name, location, declaration: declaration)
+      receiver_type = Index.actual_nesting(@stack, nil).join("::")
+      if @target.owner_ancestors.include?(receiver_type)
+        @references << Reference.new(name, location, declaration: declaration)
+      end
     end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -728,6 +728,30 @@ module RubyIndexer
       assert_equal(["A", "ALIAS"], @index.linearized_ancestors_of("A"))
     end
 
+    def test_linearizing_ancestors_for_classes_with_overridden_parents
+      index(<<~RUBY)
+        # Find the re-open of a class first, without specifying a parent
+        class Child
+        end
+
+        # Now, find the actual definition of the class, which includes a parent
+        class Parent; end
+        class Child < Parent
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Child",
+          "Parent",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Child"),
+      )
+    end
+
     def test_resolving_an_inherited_method
       index(<<~RUBY)
         module Foo

data/lib/ruby_indexer/test/method_test.rb

@@ -950,6 +950,16 @@ module RubyIndexer
       assert_predicate(entry, :public?)
     end
 
+    def test_handling_attr
+      index(<<~RUBY)
+        class Foo
+          attr :bar
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:1-8:1-11")
+    end
+
     private
 
     #: (Entry::Method entry, String call_string) -> void

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -216,22 +216,43 @@ module RubyIndexer
       assert_equal(11, refs[2].location.start_line)
     end
 
-    def test_finds_instance_variable_read_references
-      refs = find_instance_variable_references("@foo", <<~RUBY)
+    def test_finds_instance_variable_references
+      refs = find_instance_variable_references("@name", ["Foo"], <<~RUBY)
         class Foo
-          def foo
-            @foo
+          def initialize
+            @name = "foo"
+          end
+          def name
+            @name
+          end
+          def name_capital
+            @name[0]
+          end
+        end
+
+        class Bar
+          def initialize
+            @name = "foo"
+          end
+          def name
+            @name
           end
         end
       RUBY
-      assert_equal(1, refs.size)
+      assert_equal(3, refs.size)
 
-      assert_equal("@foo", refs[0].name)
+      assert_equal("@name", refs[0].name)
       assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("@name", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+
+      assert_equal("@name", refs[2].name)
+      assert_equal(9, refs[2].location.start_line)
     end
 
     def test_finds_instance_variable_write_references
-      refs = find_instance_variable_references("@foo", <<~RUBY)
+      refs = find_instance_variable_references("@foo", ["Foo"], <<~RUBY)
         class Foo
           def write
             @foo = 1
@@ -252,26 +273,70 @@ module RubyIndexer
       assert_equal(7, refs[4].location.start_line)
     end
 
-    def test_finds_instance_variable_references_ignore_context
-      refs = find_instance_variable_references("@name", <<~RUBY)
-        class Foo
+    def test_finds_instance_variable_references_in_owner_ancestors
+      refs = find_instance_variable_references("@name", ["Foo", "Base", "Top", "Parent"], <<~RUBY)
+        module Base
+          def change_name(name)
+            @name = name
+          end
           def name
+            @name
+          end
+
+          module ::Top
+            def name
+              @name
+            end
+          end
+        end
+
+        class Parent
+          def initialize
+            @name = "parent"
+          end
+          def name_capital
+            @name[0]
+          end
+        end
+
+        class Foo < Parent
+          include Base
+          def initialize
             @name = "foo"
           end
+          def name
+            @name
+          end
         end
+
         class Bar
           def name
             @name = "bar"
           end
         end
       RUBY
-      assert_equal(2, refs.size)
+      assert_equal(7, refs.size)
 
       assert_equal("@name", refs[0].name)
       assert_equal(3, refs[0].location.start_line)
 
       assert_equal("@name", refs[1].name)
-      assert_equal(8, refs[1].location.start_line)
+      assert_equal(6, refs[1].location.start_line)
+
+      assert_equal("@name", refs[2].name)
+      assert_equal(11, refs[2].location.start_line)
+
+      assert_equal("@name", refs[3].name)
+      assert_equal(18, refs[3].location.start_line)
+
+      assert_equal("@name", refs[4].name)
+      assert_equal(21, refs[4].location.start_line)
+
+      assert_equal("@name", refs[5].name)
+      assert_equal(28, refs[5].location.start_line)
+
+      assert_equal("@name", refs[6].name)
+      assert_equal(31, refs[6].location.start_line)
     end
 
     def test_accounts_for_reopened_classes
@@ -310,8 +375,8 @@ module RubyIndexer
       find_references(target, source)
     end
 
-    def find_instance_variable_references(instance_variable_name, source)
-      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name)
+    def find_instance_variable_references(instance_variable_name, owner_ancestors, source)
+      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name, owner_ancestors)
       find_references(target, source)
     end
 

data/lib/ruby_lsp/addon.rb

@@ -19,12 +19,8 @@ module RubyLsp
   #   end
   # end
   # ```
+  # @abstract
   class Addon
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     @addons = [] #: Array[Addon]
     @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
@@ -178,21 +174,25 @@ module RubyLsp
 
     # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+    # @abstract
+    #: (GlobalState, Thread::Queue) -> void
     def activate(global_state, outgoing_queue); end
 
     # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
-    sig { abstract.void }
+    # @abstract
+    #: -> void
     def deactivate; end
 
     # Add-ons should override the `name` method to return the add-on name
-    sig { abstract.returns(String) }
+    # @abstract
+    #: -> String
     def name; end
 
     # Add-ons should override the `version` method to return a semantic version string representing the add-on's
     # version. This is used for compatibility checks
-    sig { abstract.returns(String) }
+    # @abstract
+    #: -> String
     def version; end
 
     # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the

data/lib/ruby_lsp/base_server.rb

@@ -2,12 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   class BaseServer
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: (**untyped options) -> void
     def initialize(**options)
       @test_mode = options[:test_mode] #: bool?
@@ -130,10 +126,12 @@ module RubyLsp
       @incoming_queue << message
     end
 
-    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
+    # @abstract
+    #: (Hash[Symbol, untyped] message) -> void
     def process_message(message); end
 
-    sig { abstract.void }
+    # @abstract
+    #: -> void
     def shutdown; end
 
     #: (Integer id, String message, ?type: Integer) -> void

data/lib/ruby_lsp/document.rb

@@ -2,10 +2,9 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   #: [ParseResultType]
   class Document
-    extend T::Sig
-    extend T::Helpers
     extend T::Generic
 
     class LocationNotFoundError < StandardError; end
@@ -15,8 +14,6 @@ module RubyLsp
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
     EMPTY_CACHE = Object.new.freeze #: Object
 
-    abstract!
-
     #: ParseResultType
     attr_reader :parse_result
 
@@ -63,7 +60,8 @@ module RubyLsp
       self.class == other.class && uri == other.uri && @source == other.source
     end
 
-    sig { abstract.returns(Symbol) }
+    # @abstract
+    #: -> Symbol
     def language_id; end
 
     #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
@@ -122,10 +120,12 @@ module RubyLsp
     end
 
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
-    sig { abstract.returns(T::Boolean) }
+    # @abstract
+    #: -> bool
     def parse!; end
 
-    sig { abstract.returns(T::Boolean) }
+    # @abstract
+    #: -> bool
     def syntax_error?; end
 
     #: -> bool
@@ -150,12 +150,8 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
+    # @abstract
     class Edit
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Hash[Symbol, untyped]
       attr_reader :range
 

data/lib/ruby_lsp/listeners/completion.rb

@@ -516,6 +516,14 @@ module RubyLsp
 
           entry_name = entry.name
           owner_name = entry.owner&.name
+          new_text = entry_name
+
+          if entry_name.end_with?("=")
+            method_name = entry_name.delete_suffix("=")
+
+            # For writer methods, format as assignment and prefix "self." when no receiver is specified
+            new_text = node.receiver.nil? ? "self.#{method_name} = " : "#{method_name} = "
+          end
 
           label_details = Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,
@@ -525,7 +533,7 @@ module RubyLsp
             label: entry_name,
             filter_text: entry_name,
             label_details: label_details,
-            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            text_edit: Interface::TextEdit.new(range: range, new_text: new_text),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
               owner_name: owner_name,

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -41,8 +41,20 @@ module RubyLsp
 
       #: (Prism::ClassNode) -> void
       def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack.pop
         super
+      end
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack << nil
+        super
+      end
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         @spec_group_id_stack.pop
+        super
       end
 
       #: (Prism::CallNode) -> void
@@ -61,6 +73,12 @@ module RubyLsp
       def on_call_node_leave(node)
         return unless node.name == :describe && !node.receiver
 
+        current_group = @spec_group_id_stack.last
+        return unless current_group.is_a?(DescribeGroup)
+
+        description = extract_description(node)
+        return unless description && current_group.id.end_with?(description)
+
         @spec_group_id_stack.pop
       end
 
@@ -76,6 +94,8 @@ module RubyLsp
         return unless description
 
         parent = latest_group
+        return unless parent
+
         id = case parent
         when Requests::Support::TestItem
           "#{parent.id}::#{description}"
@@ -135,26 +155,50 @@ module RubyLsp
         end
       end
 
-      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)
+      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)?
       def latest_group
+        # If we haven't found anything yet, then return the response builder
         return @response_builder if @spec_group_id_stack.compact.empty?
+        # If we found something that isn't a group last, then we're inside a random module or class, but not a spec
+        # group
+        return unless @spec_group_id_stack.last
 
-        first_class_index = @spec_group_id_stack.rindex { |i| i.is_a?(ClassGroup) } || 0
-        first_class = @spec_group_id_stack[0] #: as !nil
-        item = @response_builder[first_class.id] #: as !nil
+        # Specs using at least one class as a group require special handling
+        closest_class_index = @spec_group_id_stack.rindex { |i| i.is_a?(ClassGroup) }
 
-        # Descend into child items from the beginning all the way to the latest class group, ignoring describes
-        @spec_group_id_stack[1..first_class_index] #: as !nil
-          .each do |group|
-          next unless group.is_a?(ClassGroup)
+        if closest_class_index
+          first_class_index = @spec_group_id_stack.index { |i| i.is_a?(ClassGroup) } #: as !nil
+          first_class = @spec_group_id_stack[first_class_index] #: as !nil
+          item = @response_builder[first_class.id] #: as !nil
 
-          item = item[group.id] #: as !nil
+          # Descend into child items from the beginning all the way to the latest class group, ignoring describes
+          @spec_group_id_stack[first_class_index + 1..closest_class_index] #: as !nil
+            .each do |group|
+            next unless group.is_a?(ClassGroup)
+
+            item = item[group.id] #: as !nil
+          end
+
+          # From the class forward, we must take describes into account
+          @spec_group_id_stack[closest_class_index + 1..] #: as !nil
+            .each do |group|
+            next unless group
+
+            item = item[group.id] #: as !nil
+          end
+
+          return item
         end
 
-        # From the class forward, we must take describes into account
-        @spec_group_id_stack[first_class_index + 1..] #: as !nil
+        # Specs only using describes
+        first_group = @spec_group_id_stack.find { |i| i.is_a?(DescribeGroup) }
+        return unless first_group
+
+        item = @response_builder[first_group.id] #: as !nil
+
+        @spec_group_id_stack[1..] #: as !nil
           .each do |group|
-          next unless group
+          next unless group.is_a?(DescribeGroup)
 
           item = item[group.id] #: as !nil
         end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -3,10 +3,8 @@
 
 module RubyLsp
   module Listeners
+    # @abstract
     class TestDiscovery
-      extend T::Helpers
-      abstract!
-
       include Requests::Support::Common
 
       DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"

data/lib/ruby_lsp/listeners/test_style.rb

@@ -92,7 +92,7 @@ module RubyLsp
         #: (String, Hash[String, Hash[Symbol, untyped]]) -> String
         def handle_minitest_groups(file_path, groups_and_examples)
           regexes = groups_and_examples.flat_map do |group, info|
-            examples = info[:examples].map { |e| e.gsub(/test_\d{4}/, "test_\\d{4}") }
+            examples = info[:examples].map { |e| Shellwords.escape(e).gsub(/test_\d{4}/, "test_\\d{4}") }
             group_regex = Shellwords.escape(group).gsub(
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",

data/lib/ruby_lsp/requests/code_lens.rb

@@ -18,13 +18,15 @@ module RubyLsp
         end
       end
 
-      #: (GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
-      def initialize(global_state, uri, dispatcher)
+      #: (GlobalState, RubyDocument | ERBDocument, Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
         @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
         super()
 
+        @document = document
         @test_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+        uri = document.uri
 
         if global_state.enabled_feature?(:fullTestDiscovery)
           Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
@@ -45,6 +47,7 @@ module RubyLsp
       # @override
       #: -> Array[Interface::CodeLens]
       def perform
+        @document.cache_set("rubyLsp/discoverTests", @test_builder.response)
         @response_builder.response + @test_builder.code_lens
       end
     end

data/lib/ruby_lsp/requests/references.rb

@@ -101,7 +101,11 @@ module RubyLsp
           Prism::InstanceVariableReadNode,
           Prism::InstanceVariableTargetNode,
           Prism::InstanceVariableWriteNode
-          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s)
+          receiver_type = @global_state.type_inferrer.infer_receiver_type(node_context)
+          return unless receiver_type
+
+          ancestors = @global_state.index.linearized_ancestors_of(receiver_type.name)
+          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s, ancestors)
         when Prism::CallNode, Prism::DefNode
           RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
         end

data/lib/ruby_lsp/requests/request.rb

@@ -3,15 +3,12 @@
 
 module RubyLsp
   module Requests
+    # @abstract
     class Request
-      extend T::Helpers
-      extend T::Sig
-
       class InvalidFormatter < StandardError; end
 
-      abstract!
-
-      sig { abstract.returns(T.anything) }
+      # @abstract
+      #: -> untyped
       def perform; end
 
       private

data/lib/ruby_lsp/requests/support/common.rb

@@ -4,13 +4,11 @@
 module RubyLsp
   module Requests
     module Support
+      # @requires_ancestor: Kernel
       module Common
         # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
         # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
-        extend T::Helpers
-
-        requires_ancestor { Kernel }
 
         #: (Prism::Node node) -> Interface::Range
         def range_from_node(node)

data/lib/ruby_lsp/requests/support/formatter.rb

@@ -4,24 +4,19 @@
 module RubyLsp
   module Requests
     module Support
+      # Empty module to avoid the runtime component. This is an interface defined in sorbet/rbi/shims/ruby_lsp.rbi
+      # @interface
       module Formatter
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        sig { abstract.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
+        # @abstract
+        #: (URI::Generic, RubyLsp::RubyDocument) -> String?
         def run_formatting(uri, document); end
 
-        sig { abstract.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        # @abstract
+        #: (URI::Generic, String, Integer) -> String?
         def run_range_formatting(uri, source, base_indentation); end
 
-        sig do
-          abstract.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
-        end
+        # @abstract
+        #: (URI::Generic, RubyLsp::RubyDocument) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document); end
       end
     end

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -3,14 +3,12 @@
 
 module RubyLsp
   module ResponseBuilders
+    # @abstract
     class ResponseBuilder
-      extend T::Sig
-      extend T::Helpers
       extend T::Generic
 
-      abstract!
-
-      sig { abstract.returns(T.anything) }
+      # @abstract
+      #: -> top
       def response; end
     end
   end

data/lib/ruby_lsp/server.rb

@@ -94,16 +94,7 @@ module RubyLsp
             id: message[:id],
             response:
               Addon.addons.map do |addon|
-                version_method = addon.method(:version)
-
-                # If the add-on doesn't define a `version` method, we'd be calling the abstract method defined by
-                # Sorbet, which would raise an error.
-                # Therefore, we only call the method if it's defined by the add-on itself
-                if version_method.owner != Addon
-                  version = addon.version
-                end
-
-                { name: addon.name, version: version, errored: addon.error? }
+                { name: addon.name, version: addon.version, errored: addon.error? }
               end,
           ),
         )
@@ -512,12 +503,12 @@ module RubyLsp
           @global_state.index.handle_change(uri) do |index|
             index.delete(uri, skip_require_paths_tree: true)
             RubyIndexer::DeclarationListener.new(index, dispatcher, parse_result, uri, collect_comments: true)
-            code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
+            code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
             dispatcher.dispatch(parse_result.value)
           end
         end
       else
-        code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
+        code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
         dispatcher.dispatch(parse_result.value)
       end
 

data/lib/ruby_lsp/setup_bundler.rb

@@ -12,9 +12,9 @@ require "digest"
 require "time"
 require "uri"
 
-# This file is a script that will configure a composed bundle for the Ruby LSP. The composed bundle allows developers to use
-# the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
-# exact locked versions of dependencies.
+# This file is a script that will configure a composed bundle for the Ruby LSP. The composed bundle allows developers to
+# use the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to
+# the exact locked versions of dependencies.
 
 Bundler.ui.level = :silent
 

data/lib/ruby_lsp/test_helper.rb

@@ -4,13 +4,10 @@
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
+  # @requires_ancestor: Kernel
   module TestHelper
     class TestError < StandardError; end
 
-    extend T::Helpers
-
-    requires_ancestor { Kernel }
-
     #: [T] (?String? source, ?URI::Generic uri, ?stub_no_typechecker: bool, ?load_addons: bool) { (RubyLsp::Server server, URI::Generic uri) -> T } -> T
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)

data/lib/ruby_lsp/utils.rb

@@ -34,25 +34,22 @@ module RubyLsp
   BUNDLE_COMPOSE_FAILED_CODE = -33000
 
   # A notification to be sent to the client
+  # @abstract
   class Message
-    extend T::Sig
-    extend T::Helpers
-
     #: String
     attr_reader :method
 
     #: Object
     attr_reader :params
 
-    abstract!
-
     #: (method: String, params: Object) -> void
     def initialize(method:, params:)
       @method = method
       @params = params
     end
 
-    sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
+    # @abstract
+    #: -> Hash[Symbol, untyped]
     def to_hash; end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.22
+  version: 0.23.24
 platform: ruby
 authors:
 - Shopify