ruby-lsp 0.17.15 → 0.17.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d715172510bba67801670dbfc574eed9851b9852aaea3f6e210acd74734af4
-  data.tar.gz: b35b3a55c3d65987390e4b125a090ff8f6da902bfa7ab9c08eb9eb8c72d5157f
+  metadata.gz: fc4416ea8876d8207b6c1955cd47af5f3312a0f0dc3644563bfd35138a903535
+  data.tar.gz: 5961dd8ca49539c20049509c0afed8b2442c3d16ec12d1fb84c9e45dbd027760
 SHA512:
-  metadata.gz: ef8a2ca24755eef8c5ed1146f1f6c40ec725988e9dd6a51efb326583e5606a221f733625f08d4dad5bb6091675c39fb18a485ff8c0bed1dc0b2e221a4390c585
-  data.tar.gz: 16101462585105a9a201f6341908f0b238f77f4acaa6dac723c95e35fcddc7c7b68d937bead5beecc14ae6bcac276b2f813523304f7eaded3132d3aa07eb943b
+  metadata.gz: 4b77547221c1750871ff6e1a3635b0ae6f945b86862f484d20eb7587a1feb9830e1d1d7770f16c2e7efeb70e6a953529041f8acc8fe3d7c30940687d20563f96
+  data.tar.gz: 1093a1a6ac45e8627f26a6c9dbb0017079d2804904fe9a4303e3698d4131c6eeedf2bbafac93e6475f676860624b9c53d482c52cfe8380e67ed05ce525e99957

data/VERSION

@@ -1 +1 @@
-0.17.15
+0.17.16

data/lib/ruby_lsp/document.rb

@@ -17,6 +17,11 @@ module RubyLsp
 
     ParseResultType = type_member
 
+    # 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 = T.let(Object.new.freeze, Object)
+
     abstract!
 
     sig { returns(ParseResultType) }
@@ -34,9 +39,13 @@ module RubyLsp
     sig { returns(Encoding) }
     attr_reader :encoding
 
+    sig { returns(T.any(Interface::SemanticTokens, Object)) }
+    attr_accessor :semantic_tokens
+
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
     def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
-      @cache = T.let({}, T::Hash[String, T.untyped])
+      @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
+      @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
       @encoding = T.let(encoding, Encoding)
       @source = T.let(source, String)
       @version = T.let(version, Integer)
@@ -63,7 +72,7 @@ module RubyLsp
     end
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
-      return cached if cached
+      return cached if cached != EMPTY_CACHE
 
       result = block.call(self)
       @cache[request_name] = result
@@ -108,6 +117,11 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
+    sig { returns(T::Boolean) }
+    def past_expensive_limit?
+      @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
+    end
+
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/listeners/completion.rb

@@ -366,7 +366,7 @@ module RubyLsp
 
         return unless range
 
-        guessed_type = type.name
+        guessed_type = type.is_a?(TypeInferrer::GuessedType) && type.name
 
         @index.method_completion_candidates(method_name, type.name).each do |entry|
           entry_name = entry.name

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -69,6 +69,17 @@ module RubyLsp
           tooltip: tooltip,
         )
       end
+
+      private
+
+      sig { params(node: T.nilable(Prism::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+      def visible?(node, range)
+        return true if range.nil?
+        return false if node.nil?
+
+        loc = node.location
+        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
+      end
     end
   end
 end

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -14,7 +14,7 @@ module RubyLsp
           Kernel.methods(false),
           Bundler::Dsl.instance_methods(false),
           Module.private_instance_methods(false),
-        ].flatten.map(&:to_s),
+        ].flatten.map(&:to_s).freeze,
         T::Array[String],
       )
 
@@ -22,12 +22,10 @@ module RubyLsp
         params(
           dispatcher: Prism::Dispatcher,
           response_builder: ResponseBuilders::SemanticHighlighting,
-          range: T.nilable(T::Range[Integer]),
         ).void
       end
-      def initialize(dispatcher, response_builder, range: nil)
+      def initialize(dispatcher, response_builder)
         @response_builder = response_builder
-        @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
         @current_scope = T.let(ParameterScope.new, ParameterScope)
         @inside_regex_capture = T.let(false, T::Boolean)
@@ -43,7 +41,6 @@ module RubyLsp
           :on_block_node_leave,
           :on_self_node_enter,
           :on_module_node_enter,
-          :on_local_variable_write_node_enter,
           :on_local_variable_read_node_enter,
           :on_block_parameter_node_enter,
           :on_required_keyword_parameter_node_enter,
@@ -52,16 +49,6 @@ module RubyLsp
           :on_optional_parameter_node_enter,
           :on_required_parameter_node_enter,
           :on_rest_parameter_node_enter,
-          :on_constant_read_node_enter,
-          :on_constant_write_node_enter,
-          :on_constant_and_write_node_enter,
-          :on_constant_operator_write_node_enter,
-          :on_constant_or_write_node_enter,
-          :on_constant_target_node_enter,
-          :on_constant_path_node_enter,
-          :on_local_variable_and_write_node_enter,
-          :on_local_variable_operator_write_node_enter,
-          :on_local_variable_or_write_node_enter,
           :on_local_variable_target_node_enter,
           :on_block_local_variable_node_enter,
           :on_match_write_node_enter,
@@ -74,7 +61,6 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         return if @inside_implicit_node
-        return unless visible?(node, @range)
 
         message = node.message
         return unless message
@@ -85,8 +71,14 @@ module RubyLsp
         return if message == "=~"
         return if special_method?(message)
 
-        type = Requests::Support::Sorbet.annotation?(node) ? :type : :method
-        @response_builder.add_token(T.must(node.message_loc), type)
+        if Requests::Support::Sorbet.annotation?(node)
+          @response_builder.add_token(T.must(node.message_loc), :type)
+        elsif !node.receiver && !node.opening_loc
+          # If the node has a receiver, then the syntax is not ambiguous and semantic highlighting is not necessary to
+          # determine that the token is a method call. The only ambiguous case is method calls with implicit self
+          # receiver and no parenthesis, which may be confused with local variables
+          @response_builder.add_token(T.must(node.message_loc), :method)
+        end
       end
 
       sig { params(node: Prism::MatchWriteNode).void }
@@ -104,55 +96,9 @@ module RubyLsp
         @inside_regex_capture = true if node.call.message == "=~"
       end
 
-      sig { params(node: Prism::ConstantReadNode).void }
-      def on_constant_read_node_enter(node)
-        return if @inside_implicit_node
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.location, :namespace)
-      end
-
-      sig { params(node: Prism::ConstantWriteNode).void }
-      def on_constant_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :namespace)
-      end
-
-      sig { params(node: Prism::ConstantAndWriteNode).void }
-      def on_constant_and_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :namespace)
-      end
-
-      sig { params(node: Prism::ConstantOperatorWriteNode).void }
-      def on_constant_operator_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :namespace)
-      end
-
-      sig { params(node: Prism::ConstantOrWriteNode).void }
-      def on_constant_or_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :namespace)
-      end
-
-      sig { params(node: Prism::ConstantTargetNode).void }
-      def on_constant_target_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.location, :namespace)
-      end
-
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         @current_scope = ParameterScope.new(@current_scope)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :method, [:declaration])
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -184,77 +130,43 @@ module RubyLsp
       sig { params(node: Prism::RequiredKeywordParameterNode).void }
       def on_required_keyword_parameter_node_enter(node)
         @current_scope << node.name
-        return unless visible?(node, @range)
-
-        location = node.name_loc
-        @response_builder.add_token(location.copy(length: location.length - 1), :parameter)
       end
 
       sig { params(node: Prism::OptionalKeywordParameterNode).void }
       def on_optional_keyword_parameter_node_enter(node)
         @current_scope << node.name
-        return unless visible?(node, @range)
-
-        location = node.name_loc
-        @response_builder.add_token(location.copy(length: location.length - 1), :parameter)
       end
 
       sig { params(node: Prism::KeywordRestParameterNode).void }
       def on_keyword_rest_parameter_node_enter(node)
         name = node.name
-
-        if name
-          @current_scope << name.to_sym
-
-          @response_builder.add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
-        end
+        @current_scope << name.to_sym if name
       end
 
       sig { params(node: Prism::OptionalParameterNode).void }
       def on_optional_parameter_node_enter(node)
         @current_scope << node.name
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :parameter)
       end
 
       sig { params(node: Prism::RequiredParameterNode).void }
       def on_required_parameter_node_enter(node)
         @current_scope << node.name
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.location, :parameter)
       end
 
       sig { params(node: Prism::RestParameterNode).void }
       def on_rest_parameter_node_enter(node)
         name = node.name
-
-        if name
-          @current_scope << name.to_sym
-
-          @response_builder.add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
-        end
+        @current_scope << name.to_sym if name
       end
 
       sig { params(node: Prism::SelfNode).void }
       def on_self_node_enter(node)
-        return unless visible?(node, @range)
-
         @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
-      sig { params(node: Prism::LocalVariableWriteNode).void }
-      def on_local_variable_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
-      end
-
       sig { params(node: Prism::LocalVariableReadNode).void }
       def on_local_variable_read_node_enter(node)
         return if @inside_implicit_node
-        return unless visible?(node, @range)
 
         # Numbered parameters
         if /_\d+/.match?(node.name)
@@ -265,27 +177,6 @@ module RubyLsp
         @response_builder.add_token(node.location, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: Prism::LocalVariableAndWriteNode).void }
-      def on_local_variable_and_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
-      end
-
-      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
-      def on_local_variable_operator_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
-      end
-
-      sig { params(node: Prism::LocalVariableOrWriteNode).void }
-      def on_local_variable_or_write_node_enter(node)
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
-      end
-
       sig { params(node: Prism::LocalVariableTargetNode).void }
       def on_local_variable_target_node_enter(node)
         # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.
@@ -294,15 +185,11 @@ module RubyLsp
         # prevent pushing local variable target tokens. See https://github.com/ruby/prism/issues/1912
         return if @inside_regex_capture
 
-        return unless visible?(node, @range)
-
         @response_builder.add_token(node.location, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
-        return unless visible?(node, @range)
-
         constant_path = node.constant_path
 
         if constant_path.is_a?(Prism::ConstantReadNode)
@@ -342,8 +229,6 @@ module RubyLsp
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
-        return unless visible?(node, @range)
-
         constant_path = node.constant_path
 
         if constant_path.is_a?(Prism::ConstantReadNode)
@@ -365,8 +250,6 @@ module RubyLsp
 
       sig { params(node: Prism::ImplicitNode).void }
       def on_implicit_node_enter(node)
-        return unless visible?(node, @range)
-
         @inside_implicit_node = true
       end
 
@@ -375,14 +258,6 @@ module RubyLsp
         @inside_implicit_node = false
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        return if @inside_implicit_node
-        return unless visible?(node, @range)
-
-        @response_builder.add_token(node.name_loc, :namespace)
-      end
-
       private
 
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -46,7 +46,9 @@ 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_linters.empty?
+        if @document.syntax_error? || @active_linters.empty? || @document.past_expensive_limit?
+          return diagnostics
+        end
 
         @active_linters.each do |linter|
           linter_diagnostics = linter.run_diagnostic(@uri, @document)

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -19,6 +19,16 @@ module RubyLsp
     #   some_invocation # --> semantic highlighting: method invocation
     #   var # --> semantic highlighting: local variable
     # end
+    #
+    # # Strategy
+    #
+    # To maximize editor performance, the Ruby LSP will return the minimum number of semantic tokens, since applying
+    # them is an expensive operation for the client. This means that the server only returns tokens for ambiguous pieces
+    # of syntax, such as method invocations with no receivers or parenthesis (which can be confused with local
+    # variables).
+    #
+    # Offloading as much handling as possible to Text Mate grammars or equivalent will guarantee responsiveness in the
+    # editor and allow for a much smoother experience.
     # ```
     class SemanticHighlighting < Request
       extend T::Sig
@@ -35,28 +45,125 @@ module RubyLsp
               token_modifiers: ResponseBuilders::SemanticHighlighting::TOKEN_MODIFIERS.keys,
             ),
             range: true,
-            full: { delta: false },
+            full: { delta: true },
+          )
+        end
+
+        # The compute_delta method receives the current semantic tokens and the previous semantic tokens and then tries
+        # to compute the smallest possible semantic token edit that will turn previous into current
+        sig do
+          params(
+            current_tokens: T::Array[Integer],
+            previous_tokens: T::Array[Integer],
+            result_id: String,
+          ).returns(Interface::SemanticTokensDelta)
+        end
+        def compute_delta(current_tokens, previous_tokens, result_id)
+          # Find the index of the first token that is different between the two sets of tokens
+          first_different_position = current_tokens.zip(previous_tokens).find_index { |new, old| new != old }
+
+          # When deleting a token from the end, the first_different_position will be nil, but since we're removing at
+          # the end, then we have to initialize it to the length of the current tokens after the deletion
+          if !first_different_position && current_tokens.length < previous_tokens.length
+            first_different_position = current_tokens.length
+          end
+
+          unless first_different_position
+            return Interface::SemanticTokensDelta.new(result_id: result_id, edits: [])
+          end
+
+          # Filter the tokens based on the first different position. This must happen at this stage, before we try to
+          # find the next position from the end or else we risk confusing sets of token that may have different lengths,
+          # but end with the exact same token
+          old_tokens = T.must(previous_tokens[first_different_position...])
+          new_tokens = T.must(current_tokens[first_different_position...])
+
+          # Then search from the end to find the first token that doesn't match. Since the user is normally editing the
+          # middle of the file, this will minimize the number of edits since the end of the token array has not changed
+          first_different_token_from_end = new_tokens.reverse.zip(old_tokens.reverse).find_index do |new, old|
+            new != old
+          end || 0
+
+          # Filter the old and new tokens to only the section that will be replaced/inserted/deleted
+          old_tokens = T.must(old_tokens[...old_tokens.length - first_different_token_from_end])
+          new_tokens = T.must(new_tokens[...new_tokens.length - first_different_token_from_end])
+
+          # And we send back a single edit, replacing an entire section for the new tokens
+          Interface::SemanticTokensDelta.new(
+            result_id: result_id,
+            edits: [{ start: first_different_position, deleteCount: old_tokens.length, data: new_tokens }],
           )
         end
+
+        sig { returns(Integer) }
+        def next_result_id
+          @mutex.synchronize do
+            @result_id += 1
+          end
+        end
       end
 
-      sig { params(global_state: GlobalState, dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
-      def initialize(global_state, dispatcher, range: nil)
+      @result_id = T.let(0, Integer)
+      @mutex = T.let(Mutex.new, Mutex)
+
+      sig do
+        params(
+          global_state: GlobalState,
+          dispatcher: Prism::Dispatcher,
+          document: T.any(RubyDocument, ERBDocument),
+          previous_result_id: T.nilable(String),
+          range: T.nilable(T::Range[Integer]),
+        ).void
+      end
+      def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
+
+        @document = document
+        @previous_result_id = previous_result_id
+        @range = range
+        @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
         @response_builder = T.let(
           ResponseBuilders::SemanticHighlighting.new(global_state.encoding),
           ResponseBuilders::SemanticHighlighting,
         )
-        Listeners::SemanticHighlighting.new(dispatcher, @response_builder, range: range)
+        Listeners::SemanticHighlighting.new(dispatcher, @response_builder)
 
         Addon.addons.each do |addon|
           addon.create_semantic_highlighting_listener(@response_builder, dispatcher)
         end
       end
 
-      sig { override.returns(Interface::SemanticTokens) }
+      sig { override.returns(T.any(Interface::SemanticTokens, Interface::SemanticTokensDelta)) }
       def perform
-        @response_builder.response
+        previous_tokens = @document.semantic_tokens
+        tokens = @response_builder.response
+        encoded_tokens = ResponseBuilders::SemanticHighlighting::SemanticTokenEncoder.new.encode(tokens)
+        full_response = Interface::SemanticTokens.new(result_id: @result_id, data: encoded_tokens)
+        @document.semantic_tokens = full_response
+
+        if @range
+          tokens_within_range = tokens.select { |token| @range.cover?(token.start_line - 1) }
+
+          return Interface::SemanticTokens.new(
+            result_id: @result_id,
+            data: ResponseBuilders::SemanticHighlighting::SemanticTokenEncoder.new.encode(tokens_within_range),
+          )
+        end
+
+        # Semantic tokens full delta
+        if @previous_result_id
+          response = if previous_tokens.is_a?(Interface::SemanticTokens) &&
+              previous_tokens.result_id == @previous_result_id
+            Requests::SemanticHighlighting.compute_delta(encoded_tokens, previous_tokens.data, @result_id)
+          else
+            full_response
+          end
+
+          return response
+        end
+
+        # Semantic tokens full
+        full_response
       end
     end
   end

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

@@ -37,15 +37,6 @@ module RubyLsp
           )
         end
 
-        sig { params(node: T.nilable(Prism::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
-        def visible?(node, range)
-          return true if range.nil?
-          return false if node.nil?
-
-          loc = node.location
-          range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
-        end
-
         sig do
           params(
             node: Prism::Node,

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -91,9 +91,9 @@ module RubyLsp
         @stack.last
       end
 
-      sig { override.returns(Interface::SemanticTokens) }
+      sig { override.returns(T::Array[SemanticToken]) }
       def response
-        SemanticTokenEncoder.new.encode(@stack)
+        @stack
       end
 
       class SemanticToken
@@ -162,7 +162,7 @@ module RubyLsp
         sig do
           params(
             tokens: T::Array[SemanticToken],
-          ).returns(Interface::SemanticTokens)
+          ).returns(T::Array[Integer])
         end
         def encode(tokens)
           sorted_tokens = tokens.sort_by.with_index do |token, index|
@@ -176,7 +176,7 @@ module RubyLsp
             compute_delta(token)
           end
 
-          Interface::SemanticTokens.new(data: delta)
+          delta
         end
 
         # The delta array is computed according to the LSP specification:

data/lib/ruby_lsp/server.rb

@@ -23,6 +23,7 @@ module RubyLsp
         run_initialize(message)
       when "initialized"
         send_log_message("Finished initializing Ruby LSP!") unless @test_mode
+
         run_initialized
       when "textDocument/didOpen"
         text_document_did_open(message)
@@ -40,6 +41,8 @@ module RubyLsp
         text_document_code_lens(message)
       when "textDocument/semanticTokens/full"
         text_document_semantic_tokens_full(message)
+      when "textDocument/semanticTokens/full/delta"
+        text_document_semantic_tokens_delta(message)
       when "textDocument/foldingRange"
         text_document_folding_range(message)
       when "textDocument/semanticTokens/range"
@@ -304,13 +307,26 @@ module RubyLsp
           Document::LanguageId::Ruby
         end
 
-        @store.set(
+        document = @store.set(
           uri: text_document[:uri],
           source: text_document[:text],
           version: text_document[:version],
           encoding: @global_state.encoding,
           language_id: language_id,
         )
+
+        if document.past_expensive_limit?
+          send_message(
+            Notification.new(
+              method: "window/showMessage",
+              params: Interface::ShowMessageParams.new(
+                type: Constant::MessageType::WARNING,
+                message: "This file is too long. For performance reasons, semantic highlighting and " \
+                  "diagnostics will be disabled",
+              ),
+            ),
+          )
+        end
       end
     end
 
@@ -378,7 +394,7 @@ module RubyLsp
 
       # If the response has already been cached by another request, return it
       cached_response = document.cache_get(message[:method])
-      if cached_response
+      if cached_response != Document::EMPTY_CACHE
         send_message(Result.new(id: message[:id], response: cached_response))
         return
       end
@@ -391,8 +407,6 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-
-      semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher)
       dispatcher.dispatch(parse_result.value)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -401,19 +415,61 @@ module RubyLsp
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
       document.cache_set("textDocument/codeLens", code_lens.perform)
-      document.cache_set(
-        "textDocument/semanticTokens/full",
-        semantic_highlighting.perform,
-      )
+
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))
     end
 
     alias_method :text_document_document_symbol, :run_combined_requests
     alias_method :text_document_document_link, :run_combined_requests
     alias_method :text_document_code_lens, :run_combined_requests
-    alias_method :text_document_semantic_tokens_full, :run_combined_requests
     alias_method :text_document_folding_range, :run_combined_requests
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_semantic_tokens_full(message)
+      document = @store.get(message.dig(:params, :textDocument, :uri))
+
+      if document.past_expensive_limit?
+        send_empty_response(message[:id])
+        return
+      end
+
+      unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      dispatcher = Prism::Dispatcher.new
+      semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher, document, nil)
+      dispatcher.visit(document.parse_result.value)
+
+      send_message(Result.new(id: message[:id], response: semantic_highlighting.perform))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_semantic_tokens_delta(message)
+      document = @store.get(message.dig(:params, :textDocument, :uri))
+
+      if document.past_expensive_limit?
+        send_empty_response(message[:id])
+        return
+      end
+
+      unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      dispatcher = Prism::Dispatcher.new
+      request = Requests::SemanticHighlighting.new(
+        @global_state,
+        dispatcher,
+        document,
+        message.dig(:params, :previousResultId),
+      )
+      dispatcher.visit(document.parse_result.value)
+      send_message(Result.new(id: message[:id], response: request.perform))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_semantic_tokens_range(message)
       params = message[:params]
@@ -421,20 +477,26 @@ module RubyLsp
       uri = params.dig(:textDocument, :uri)
       document = @store.get(uri)
 
-      unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+      if document.past_expensive_limit?
         send_empty_response(message[:id])
         return
       end
 
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
+      unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+        send_empty_response(message[:id])
+        return
+      end
 
       dispatcher = Prism::Dispatcher.new
-      request = Requests::SemanticHighlighting.new(@global_state, dispatcher, range: start_line..end_line)
+      request = Requests::SemanticHighlighting.new(
+        @global_state,
+        dispatcher,
+        document,
+        nil,
+        range: range.dig(:start, :line)..range.dig(:end, :line),
+      )
       dispatcher.visit(document.parse_result.value)
-
-      response = request.perform
-      send_message(Result.new(id: message[:id], response: response))
+      send_message(Result.new(id: message[:id], response: request.perform))
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }

data/lib/ruby_lsp/store.rb

@@ -66,7 +66,7 @@ module RubyLsp
         version: Integer,
         language_id: Document::LanguageId,
         encoding: Encoding,
-      ).void
+      ).returns(Document[T.untyped])
     end
     def set(uri:, source:, version:, language_id:, encoding: Encoding::UTF_8)
       @state[uri.to_s] = case language_id

data/lib/ruby_lsp/test_helper.rb

@@ -20,8 +20,8 @@ module RubyLsp
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)
       server = RubyLsp::Server.new(test_mode: true)
-      server.global_state.stubs(:has_type_checker).returns(false) if stub_no_typechecker
       server.global_state.apply_options({ initializationOptions: { experimentalFeaturesEnabled: true } })
+      server.global_state.instance_variable_set(:@has_type_checker, false) if stub_no_typechecker
       language_id = uri.to_s.end_with?(".erb") ? "erb" : "ruby"
 
       if source

data/lib/ruby_lsp/type_inferrer.rb

@@ -36,9 +36,47 @@ module RubyLsp
     def infer_receiver_for_call_node(node, node_context)
       receiver = node.receiver
 
+      # For receivers inside parenthesis, such as ranges like (0...2), we need to unwrap the parenthesis to get the
+      # actual node
+      if receiver.is_a?(Prism::ParenthesesNode)
+        statements = receiver.body
+
+        if statements.is_a?(Prism::StatementsNode)
+          body = statements.body
+
+          if body.length == 1
+            receiver = body.first
+          end
+        end
+      end
+
       case receiver
       when Prism::SelfNode, nil
         self_receiver_handling(node_context)
+      when Prism::StringNode
+        Type.new("String")
+      when Prism::SymbolNode
+        Type.new("Symbol")
+      when Prism::ArrayNode
+        Type.new("Array")
+      when Prism::HashNode
+        Type.new("Hash")
+      when Prism::IntegerNode
+        Type.new("Integer")
+      when Prism::FloatNode
+        Type.new("Float")
+      when Prism::RegularExpressionNode
+        Type.new("Regexp")
+      when Prism::NilNode
+        Type.new("NilClass")
+      when Prism::TrueNode
+        Type.new("TrueClass")
+      when Prism::FalseNode
+        Type.new("FalseClass")
+      when Prism::RangeNode
+        Type.new("Range")
+      when Prism::LambdaNode
+        Type.new("Proc")
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.15
+  version: 0.17.16
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-20 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol