ruby-lsp 0.16.4 → 0.16.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94d4dfcda701bdf2ea1dd04e2a271572a139fe3d716e1bd535e2c05bcc9b3d23
-  data.tar.gz: b79dfc816bf027e733fa5f44db3e2d1039ae860f9dee88fe996ab1a27089d467
+  metadata.gz: d725a0a2fbd58820e2a87efae85564498221feb8410292055b0caafd889284e6
+  data.tar.gz: 5376ca8a9d08ca0883fca3aa19a1a178102eb60f49ab3fe5f07bb1a58ba63ddf
 SHA512:
-  metadata.gz: 9de1f73feba2284c75294542a0e9ae1196f092004fe83ef815b2e08a1b404daceebc0b3f6f8f59149f936c8f7414821942556bee522776a909c071765dcc3443
-  data.tar.gz: b7617a6d508a94e5a06b8d39acb4d2bcc28d02832b19ab8567ed58b6b297aa3fc450dd0a116257fe91fc9545683550456c0d712fc32dc3f3ff716e2cdca2985e
+  metadata.gz: 81fbb2e5018ad55d8888c98e277e7ac6ed8b45314627b1a3e3dabde2cb8aac0284dc70487a694226e5a08817feb82b64daadfcb955e9642b288e575189a56015
+  data.tar.gz: f32ef084e4412752cc32df55da0dd7b985d3826db110bf91ba3473773043c50345ceb597432483a0a75f1790cabfca796fa9581d3ba86edff96a8642fb2312f2

data/VERSION

@@ -1 +1 @@
-0.16.4
+0.16.6

data/exe/ruby-lsp

@@ -75,14 +75,18 @@ require "ruby_lsp/internal"
 
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
-    puts "Debugging is not supported on Windows"
+    $stderr.puts "Debugging is not supported on Windows"
     exit 1
   end
 
   begin
+    original_stdout = $stdout
+    $stdout = $stderr
     require "debug/open_nonstop"
   rescue LoadError
-    warn("You need to install the debug gem to use the --debug flag")
+    $stderr.puts("You need to install the debug gem to use the --debug flag")
+  ensure
+    $stdout = original_stdout
   end
 end
 

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -56,6 +56,7 @@ module RubyIndexer
         load_path_entry = T.let(nil, T.nilable(String))
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+          path = File.expand_path(path)
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
           # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
           # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but

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

@@ -11,7 +11,7 @@ module RubyIndexer
     sig { returns(String) }
     attr_reader :file_path
 
-    sig { returns(Prism::Location) }
+    sig { returns(RubyIndexer::Location) }
     attr_reader :location
 
     sig { returns(T::Array[String]) }
@@ -20,13 +20,33 @@ module RubyIndexer
     sig { returns(Symbol) }
     attr_accessor :visibility
 
-    sig { params(name: String, file_path: String, location: Prism::Location, comments: T::Array[String]).void }
+    sig do
+      params(
+        name: String,
+        file_path: String,
+        location: T.any(Prism::Location, RubyIndexer::Location),
+        comments: T::Array[String],
+      ).void
+    end
     def initialize(name, file_path, location, comments)
       @name = name
       @file_path = file_path
-      @location = location
       @comments = comments
       @visibility = T.let(:public, Symbol)
+
+      @location = T.let(
+        if location.is_a?(Prism::Location)
+          Location.new(
+            location.start_line,
+            location.end_line,
+            location.start_column,
+            location.end_column,
+          )
+        else
+          location
+        end,
+        RubyIndexer::Location,
+      )
     end
 
     sig { returns(String) }
@@ -41,28 +61,13 @@ module RubyIndexer
       abstract!
 
       sig { returns(T::Array[String]) }
-      attr_accessor :included_modules
-
-      sig { returns(T::Array[String]) }
-      attr_accessor :prepended_modules
-
-      sig do
-        params(
-          name: String,
-          file_path: String,
-          location: Prism::Location,
-          comments: T::Array[String],
-        ).void
-      end
-      def initialize(name, file_path, location, comments)
-        super(name, file_path, location, comments)
-        @included_modules = T.let([], T::Array[String])
-        @prepended_modules = T.let([], T::Array[String])
+      def included_modules
+        @included_modules ||= T.let([], T.nilable(T::Array[String]))
       end
 
-      sig { returns(String) }
-      def short_name
-        T.must(@name.split("::").last)
+      sig { returns(T::Array[String]) }
+      def prepended_modules
+        @prepended_modules ||= T.let([], T.nilable(T::Array[String]))
       end
     end
 
@@ -81,7 +86,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parent_class: T.nilable(String),
         ).void
@@ -181,7 +186,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           owner: T.nilable(Entry::Namespace),
         ).void
@@ -219,7 +224,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
           owner: T.nilable(Entry::Namespace),
@@ -349,7 +354,7 @@ module RubyIndexer
           nesting: T::Array[String],
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
         ).void
       end

data/lib/ruby_indexer/lib/ruby_indexer/location.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Location
+    extend T::Sig
+
+    sig { returns(Integer) }
+    attr_reader :start_line, :end_line, :start_column, :end_column
+
+    sig do
+      params(
+        start_line: Integer,
+        end_line: Integer,
+        start_column: Integer,
+        end_column: Integer,
+      ).void
+    end
+    def initialize(start_line, end_line, start_column, end_column)
+      @start_line = start_line
+      @end_line = end_line
+      @start_column = start_column
+      @end_column = end_column
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -10,6 +10,7 @@ require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"
 require "ruby_indexer/lib/ruby_indexer/prefix_tree"
+require "ruby_indexer/lib/ruby_indexer/location"
 
 module RubyIndexer
   @configuration = T.let(Configuration.new, Configuration)

data/lib/ruby_indexer/test/configuration_test.rb

@@ -20,6 +20,14 @@ module RubyIndexer
       assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
     end
 
+    def test_indexables_have_expanded_full_paths
+      @config.apply_config({ "included_patterns" => ["**/*.rb"] })
+      indexables = @config.indexables
+
+      # All paths should be expanded
+      assert(indexables.none? { |indexable| indexable.full_path.start_with?("lib/") })
+    end
+
     def test_indexables_only_includes_gem_require_paths
       indexables = @config.indexables
 

data/lib/ruby_lsp/base_server.rb

@@ -62,7 +62,7 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           process_message(message)
         when "shutdown"
           $stderr.puts("Shutting down Ruby LSP...")

data/lib/ruby_lsp/global_state.rb

@@ -29,8 +29,9 @@ module RubyLsp
       @encoding = T.let(Encoding::UTF_8, Encoding)
 
       @formatter = T.let("auto", String)
-      @test_library = T.let(detect_test_library, String)
-      @typechecker = T.let(detect_typechecker, T::Boolean)
+      @linters = T.let([], T::Array[String])
+      @test_library = T.let("minitest", String)
+      @typechecker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
@@ -46,14 +47,25 @@ module RubyLsp
       @supported_formatters[@formatter]
     end
 
+    sig { returns(T::Array[Requests::Support::Formatter]) }
+    def active_linters
+      @linters.filter_map { |name| @supported_formatters[name] }
+    end
+
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
     def apply_options(options)
+      dependencies = gather_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
       @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter if @formatter == "auto"
+      @formatter = detect_formatter(dependencies) if @formatter == "auto"
+
+      specified_linters = options.dig(:initializationOptions, :linters)
+      @linters = specified_linters || detect_linters(dependencies)
+      @test_library = detect_test_library(dependencies)
+      @typechecker = detect_typechecker(dependencies)
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -89,28 +101,32 @@ module RubyLsp
       end
     end
 
-    sig { params(gem_pattern: Regexp).returns(T::Boolean) }
-    def direct_dependency?(gem_pattern)
-      dependencies.any?(gem_pattern)
-    end
-
     private
 
-    sig { returns(String) }
-    def detect_formatter
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_formatter(dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      if direct_dependency?(/^rubocop/)
+      if dependencies.any?(/^rubocop/)
         "rubocop"
-      elsif direct_dependency?(/^syntax_tree$/)
+      elsif dependencies.any?(/^syntax_tree$/)
         "syntax_tree"
       else
         "none"
       end
     end
 
-    sig { returns(String) }
-    def detect_test_library
-      if direct_dependency?(/^rspec/)
+    # 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)
+      linters = []
+      linters << "rubocop" if dependencies.any?(/^rubocop/)
+      linters
+    end
+
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_test_library(dependencies)
+      if dependencies.any?(/^rspec/)
         "rspec"
       # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
       # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
@@ -119,23 +135,23 @@ module RubyLsp
       elsif File.exist?(File.join(workspace_path, "bin/rails"))
         "rails"
       # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
-      elsif direct_dependency?(/^minitest$/)
+      elsif dependencies.any?(/^minitest$/)
         "minitest"
-      elsif direct_dependency?(/^test-unit/)
+      elsif dependencies.any?(/^test-unit/)
         "test-unit"
       else
         "unknown"
       end
     end
 
-    sig { returns(T::Boolean) }
-    def detect_typechecker
+    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
       # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
       ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
       Bundler.with_original_env do
-        sorbet_static_detected = Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        sorbet_static_detected = dependencies.any?(/^sorbet-static/)
         # Don't show message while running tests, since it's noisy
         if sorbet_static_detected && !ruby_lsp_env_is_test
           $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
@@ -147,16 +163,11 @@ module RubyLsp
     end
 
     sig { returns(T::Array[String]) }
-    def dependencies
-      @dependencies ||= T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_gemfile }
-          Bundler.locked_gems.dependencies.keys + gemspec_dependencies
-        rescue Bundler::GemfileNotFound
-          []
-        end,
-        T.nilable(T::Array[String]),
-      )
+    def gather_dependencies
+      Bundler.with_original_env { Bundler.default_gemfile }
+      Bundler.locked_gems.dependencies.keys + gemspec_dependencies
+    rescue Bundler::GemfileNotFound
+      []
     end
 
     sig { returns(T::Array[String]) }

data/lib/ruby_lsp/listeners/definition.rb

@@ -7,6 +7,8 @@ module RubyLsp
       extend T::Sig
       include Requests::Support::Common
 
+      MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 10
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
@@ -64,12 +66,17 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def handle_method_definition(node)
-        return unless self_receiver?(node)
-
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @nesting.join("::"))
+        methods = if self_receiver?(node)
+          @index.resolve_method(message, @nesting.join("::"))
+        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
+          @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        end
+
         return unless methods
 
         methods.each do |target_method|

data/lib/ruby_lsp/requests/definition.rb

@@ -43,6 +43,7 @@ module RubyLsp
           ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::Location],
         )
+        @dispatcher = dispatcher
 
         target, parent, nesting = document.locate_node(
           position,
@@ -50,33 +51,41 @@ module RubyLsp
         )
 
         if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          # If the target is part of a constant path node, we need to find the exact portion of the constant that the
+          # user is requesting to go to definition for
           target = determine_target(
             target,
             parent,
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+          # If the target is a method call, we need to ensure that the requested position is exactly on top of the
+          # method identifier. Otherwise, we risk showing definitions for unrelated things
+          target = nil
         end
 
-        Listeners::Definition.new(
-          @response_builder,
-          global_state,
-          document.uri,
-          nesting,
-          dispatcher,
-          typechecker_enabled,
-        )
+        if target
+          Listeners::Definition.new(
+            @response_builder,
+            global_state,
+            document.uri,
+            nesting,
+            dispatcher,
+            typechecker_enabled,
+          )
 
-        Addon.addons.each do |addon|
-          addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          Addon.addons.each do |addon|
+            addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          end
         end
 
         @target = T.let(target, T.nilable(Prism::Node))
-        @dispatcher = dispatcher
       end
 
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
-        @dispatcher.dispatch_once(@target)
+        @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
       end
     end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -34,7 +34,7 @@ module RubyLsp
       sig { params(global_state: GlobalState, document: Document).void }
       def initialize(global_state, document)
         super()
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+        @active_linters = T.let(global_state.active_linters, T::Array[Support::Formatter])
         @document = document
         @uri = T.let(document.uri, URI::Generic)
       end
@@ -45,10 +45,13 @@ module RubyLsp
         diagnostics.concat(syntax_error_diagnostics, syntax_warning_diagnostics)
 
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
-        return diagnostics if @document.syntax_error? || !@active_formatter
+        return diagnostics if @document.syntax_error? || @active_linters.empty?
+
+        @active_linters.each do |linter|
+          linter_diagnostics = linter.run_diagnostic(@uri, @document)
+          diagnostics.concat(linter_diagnostics) if linter_diagnostics
+        end
 
-        formatter_diagnostics = @active_formatter.run_diagnostic(@uri, @document)
-        diagnostics.concat(formatter_diagnostics) if formatter_diagnostics
         diagnostics
       end
 

data/lib/ruby_lsp/requests/hover.rb

@@ -41,25 +41,29 @@ module RubyLsp
       end
       def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
-        @target = T.let(nil, T.nilable(Prism::Node))
-        @target, parent, nesting = document.locate_node(
+        target, parent, nesting = document.locate_node(
           position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
         )
 
         if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-            !Listeners::Hover::ALLOWED_TARGETS.include?(@target.class)) ||
-            (parent.is_a?(Prism::ConstantPathNode) && @target.is_a?(Prism::ConstantReadNode))
-          @target = determine_target(
-            T.must(@target),
+            !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+            (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+          target = determine_target(
+            T.must(target),
             T.must(parent),
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+
+          target = nil
         end
 
         # Don't need to instantiate any listeners if there's no target
-        return unless @target
+        return unless target
 
+        @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
         Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)

data/lib/ruby_lsp/requests/request.rb

@@ -65,6 +65,20 @@ module RubyLsp
 
         target
       end
+
+      # Checks if a given location covers the position requested
+      sig { params(location: T.nilable(Prism::Location), position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def covers_position?(location, position)
+        return false unless location
+
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        line = position[:line]
+        character = position[:character]
+
+        (start_line < line || (start_line == line && location.start_column <= character)) &&
+          (end_line > line || (end_line == line && location.end_column >= character))
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -40,10 +40,13 @@ module RubyLsp
         end
       end
 
-      sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
-      def initialize(dispatcher, range: nil)
+      sig { params(global_state: GlobalState, dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
+      def initialize(global_state, dispatcher, range: nil)
         super()
-        @response_builder = T.let(ResponseBuilders::SemanticHighlighting.new, ResponseBuilders::SemanticHighlighting)
+        @response_builder = T.let(
+          ResponseBuilders::SemanticHighlighting.new(global_state.encoding),
+          ResponseBuilders::SemanticHighlighting,
+        )
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder, range: range)
 
         Addon.addons.each do |addon|

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -55,19 +55,21 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig { void }
-      def initialize
-        super
+      sig { params(encoding: Encoding).void }
+      def initialize(encoding)
+        super()
+        @encoding = encoding
         @stack = T.let([], T::Array[SemanticToken])
       end
 
       sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
-        length = location.end_offset - location.start_offset
+        length = location.end_code_units_offset(@encoding) - location.start_code_units_offset(@encoding)
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
         @stack.push(
           SemanticToken.new(
-            location: location,
+            start_line: location.start_line,
+            start_code_unit_column: location.start_code_units_column(@encoding),
             length: length,
             type: T.must(TOKEN_TYPES[type]),
             modifier: modifiers_indices,
@@ -75,6 +77,15 @@ module RubyLsp
         )
       end
 
+      sig { params(location: Prism::Location).returns(T::Boolean) }
+      def last_token_matches?(location)
+        token = @stack.last
+        return false unless token
+
+        token.start_line == location.start_line &&
+          token.start_code_unit_column == location.start_code_units_column(@encoding)
+      end
+
       sig { returns(T.nilable(SemanticToken)) }
       def last
         @stack.last
@@ -88,8 +99,11 @@ module RubyLsp
       class SemanticToken
         extend T::Sig
 
-        sig { returns(Prism::Location) }
-        attr_reader :location
+        sig { returns(Integer) }
+        attr_reader :start_line
+
+        sig { returns(Integer) }
+        attr_reader :start_code_unit_column
 
         sig { returns(Integer) }
         attr_reader :length
@@ -100,9 +114,18 @@ module RubyLsp
         sig { returns(T::Array[Integer]) }
         attr_reader :modifier
 
-        sig { params(location: Prism::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
-        def initialize(location:, length:, type:, modifier:)
-          @location = location
+        sig do
+          params(
+            start_line: Integer,
+            start_code_unit_column: Integer,
+            length: Integer,
+            type: Integer,
+            modifier: T::Array[Integer],
+          ).void
+        end
+        def initialize(start_line:, start_code_unit_column:, length:, type:, modifier:)
+          @start_line = start_line
+          @start_code_unit_column = start_code_unit_column
           @length = length
           @type = type
           @modifier = modifier
@@ -146,7 +169,7 @@ module RubyLsp
             # Enumerable#sort_by is not deterministic when the compared values are equal.
             # When that happens, we need to use the index as a tie breaker to ensure
             # that the order of the tokens is always the same.
-            [token.location.start_line, token.location.start_column, index]
+            [token.start_line, token.start_code_unit_column, index]
           end
 
           delta = sorted_tokens.flat_map do |token|
@@ -167,8 +190,8 @@ module RubyLsp
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
         sig { params(token: SemanticToken).returns(T::Array[Integer]) }
         def compute_delta(token)
-          row = token.location.start_line - 1
-          column = token.location.start_column
+          row = token.start_line - 1
+          column = token.start_code_unit_column
 
           begin
             delta_line = row - @current_row

data/lib/ruby_lsp/server.rb

@@ -334,7 +334,7 @@ module RubyLsp
       document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
 
-      semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
+      semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher)
       dispatcher.dispatch(document.tree)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -366,7 +366,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      request = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
+      request = Requests::SemanticHighlighting.new(@global_state, dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
       response = request.perform

data/lib/ruby_lsp/utils.rb

@@ -75,7 +75,7 @@ module RubyLsp
   class Request < Message
     extend T::Sig
 
-    sig { params(id: Integer, method: String, params: Object).void }
+    sig { params(id: T.any(Integer, String), method: String, params: Object).void }
     def initialize(id:, method:, params:)
       @id = id
       super(method: method, params: params)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.4
+  version: 0.16.6
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-11 00:00:00.000000000 Z
+date: 2024-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.28'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +83,7 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
+- lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
@@ -177,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.7
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby