ruby-lsp 0.23.23 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2079a33c4ec7e87a6b90bcb3cc11eca81e0d2a9c6d591c2fc14b07234b56c60b
-  data.tar.gz: 2837a0acd68b11e065236fb3190baee2e358520694710676fe214e125ae74902
+  metadata.gz: 575c7b2510306819184c495560cc9bf9dee6dd9151cbeabe0ba3a8085996f58d
+  data.tar.gz: 0f714d35b90754c5c37672fef82a75ab5e0a2358ba821c397a3191a28518c9d3
 SHA512:
-  metadata.gz: fd82d565032cf65414ea926313dfbb7be1c5a21c1d49f9191ed6b9d3c6f4d28458db21f78f14d37af03b84223dc40e4d8cb4c24a1a4a754359757048d84e930a
-  data.tar.gz: 48c1dd2271b23e585c37a941db30729d727ceaffb7c12c1b3f806a138834192b9073df72c83bec48a7015bad7d2b109e08f591dc0a69767c39a30c8a6bd96c94
+  metadata.gz: f909d33820859b7e6a6be0e75345b00397a0717fdc5f63cfddf84b7277e7420469439f2a8d48561b96ae20f91bcbfd9ee9444522ec11e9da4611ac6371aeb52a
+  data.tar.gz: 866291dfe01240d91b1e8adfc74cc16482a5ddf9c68fc763f6869145e78ca4ea35f47f0e3727b1c1d930cc140e60e3e23c979bf68fc97a26eb6b2cd45c9403b4

data/VERSION

@@ -1 +1 @@
-0.23.23
+0.24.0

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

@@ -9,7 +9,7 @@ module RubyIndexer
     #: Array[String]
     attr_reader :indexing_errors
 
-    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
+    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseLexResult | Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
     def initialize(index, dispatcher, parse_result, uri, collect_comments: false)
       @index = index
       @uri = uri
@@ -260,6 +260,9 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :attr
+        has_writer = node.arguments&.arguments&.last&.is_a?(Prism::TrueNode) || false
+        handle_attribute(node, reader: true, writer: has_writer)
       when :alias_method
         handle_alias_method(node)
       when :include, :prepend, :extend
@@ -726,6 +729,9 @@ module RubyIndexer
         comment = @comments_by_line[line]
         break unless comment
 
+        # a trailing comment from a previous line is not a comment for this node
+        break if comment.trailing?
+
         comment_content = comment.location.slice
 
         # invalid encodings would raise an "invalid byte sequence" exception

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/instance_variables_test.rb

@@ -236,5 +236,29 @@ module RubyIndexer
       assert_instance_of(Entry::SingletonClass, owner)
       assert_equal("Foo::<Class:Foo>", owner&.name)
     end
+
+    def test_class_instance_variable_comments
+      index(<<~RUBY)
+          class Foo
+            # Documentation for @a
+            @a = "Hello" #: String
+            @b = "World" # trailing comment
+            @c = "!"
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
+      entry = @index["@a"]&.first #: as Entry::InstanceVariable
+      assert_equal("Documentation for @a", entry.comments)
+
+      assert_entry("@b", Entry::InstanceVariable, "/fake/path/foo.rb:3-4:3-6")
+      entry = @index["@b"]&.first #: as Entry::InstanceVariable
+      assert_empty(entry.comments)
+
+      assert_entry("@c", Entry::InstanceVariable, "/fake/path/foo.rb:4-4:4-6")
+      entry = @index["@c"]&.first #: as Entry::InstanceVariable
+      assert_empty(entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -950,6 +950,23 @@ module RubyIndexer
       assert_predicate(entry, :public?)
     end
 
+    def test_handling_attr
+      index(<<~RUBY)
+        class Foo
+          attr :bar
+          attr :baz, true
+          attr :qux, false
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:1-8:1-11")
+      assert_no_entry("bar=")
+      assert_entry("baz", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
+      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
+      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:3-8:3-11")
+      assert_no_entry("qux=")
+    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,21 +2,16 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   #: [ParseResultType]
   class Document
-    extend T::Sig
-    extend T::Helpers
     extend T::Generic
 
-    class LocationNotFoundError < StandardError; end
-
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
     EMPTY_CACHE = Object.new.freeze #: Object
 
-    abstract!
-
     #: ParseResultType
     attr_reader :parse_result
 
@@ -63,7 +58,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 +118,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 +148,8 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
+    # @abstract
     class Edit
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Hash[Symbol, untyped]
       attr_reader :range
 
@@ -180,7 +174,7 @@ module RubyLsp
       def initialize(source, encoding)
         @current_line = 0 #: Integer
         @pos = 0 #: Integer
-        @source = source.codepoints #: Array[Integer]
+        @bytes_or_codepoints = encoding == Encoding::UTF_8 ? source.bytes : source.codepoints #: Array[Integer]
         @encoding = encoding
       end
 
@@ -189,23 +183,40 @@ module RubyLsp
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          until LINE_BREAK == @source[@pos]
-            @pos += 1
+          @pos += 1 until LINE_BREAK == @bytes_or_codepoints[@pos]
+          @pos += 1
+          @current_line += 1
+        end
 
-            if @pos >= @source.length
-              # Pack the code points back into the original string to provide context in the error message
-              raise LocationNotFoundError, "Requested position: #{position}\nSource:\n\n#{@source.pack("U*")}"
+        # For UTF-8, the code unit length is the same as bytes, but we want to return the character index
+        requested_position = if @encoding == Encoding::UTF_8
+          character_offset = 0
+          i = @pos
+
+          # Each group of bytes is a character. We advance based on the number of bytes to count how many full
+          # characters we have in the requested offset
+          while i < @pos + position[:character] && i < @bytes_or_codepoints.length
+            byte = @bytes_or_codepoints[i] #: as !nil
+            i += if byte < 0x80 # 1-byte character
+              1
+            elsif byte < 0xE0 # 2-byte character
+              2
+            elsif byte < 0xF0 # 3-byte character
+              3
+            else # 4-byte character
+              4
             end
+
+            character_offset += 1
           end
 
-          @pos += 1
-          @current_line += 1
+          @pos + character_offset
+        else
+          @pos + position[:character]
         end
 
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
-        requested_position = @pos + position[:character]
-
         if @encoding == Encoding::UTF_16LE
           requested_position -= utf_16_character_position_correction(@pos, requested_position)
         end
@@ -220,7 +231,7 @@ module RubyLsp
         utf16_unicode_correction = 0
 
         until current_position == requested_position
-          codepoint = @source[current_position]
+          codepoint = @bytes_or_codepoints[current_position]
           utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
 
           current_position += 1

data/lib/ruby_lsp/erb_document.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  #: [ParseResultType = Prism::ParseResult]
+  #: [ParseResultType = Prism::ParseLexResult]
   class ERBDocument < Document
     #: String
     attr_reader :host_language_source
@@ -31,11 +31,16 @@ module RubyLsp
       @host_language_source = scanner.host_language
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
-      @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @parse_result = Prism.parse_lex(scanner.ruby, partial_script: true)
       @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
+    #: -> Prism::ProgramNode
+    def ast
+      @parse_result.value.first
+    end
+
     # @override
     #: -> bool
     def syntax_error?
@@ -53,7 +58,7 @@ module RubyLsp
       char_position, _ = find_index_by_position(position)
 
       RubyDocument.locate(
-        @parse_result.value,
+        ast,
         char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,