ruby-lsp 0.17.15 → 0.17.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d715172510bba67801670dbfc574eed9851b9852aaea3f6e210acd74734af4
-  data.tar.gz: b35b3a55c3d65987390e4b125a090ff8f6da902bfa7ab9c08eb9eb8c72d5157f
+  metadata.gz: e4b4c9204834ddf87c84009003c5eef5872211eaef6ed64022a93a2749e1849e
+  data.tar.gz: 0d770cf2f67f90fb974a9fca08d9fb4dea1a73d668984ff96e5cc5785d7c5766
 SHA512:
-  metadata.gz: ef8a2ca24755eef8c5ed1146f1f6c40ec725988e9dd6a51efb326583e5606a221f733625f08d4dad5bb6091675c39fb18a485ff8c0bed1dc0b2e221a4390c585
-  data.tar.gz: 16101462585105a9a201f6341908f0b238f77f4acaa6dac723c95e35fcddc7c7b68d937bead5beecc14ae6bcac276b2f813523304f7eaded3132d3aa07eb943b
+  metadata.gz: 3534227d67761a6738c5e2ae4a06a08964a0836c4a30c9d306917efdd93aae1285d6ed03992e88486a44e5d3f7e7271997e56bbb12ab908599687c6a1e622cb4
+  data.tar.gz: 5345bcf362b6206a0be392eebe5db2175fe9d06b1a38f113fe11d979e5fdcc48851cb47e5f016ae49726ffc73432e81ef801522588cee79ebb36fe545e02d965

data/VERSION

@@ -1 +1 @@
-0.17.15
+0.17.17

data/exe/ruby-lsp

@@ -98,16 +98,17 @@ if options[:debug]
 end
 
 if options[:time_index]
-  require "benchmark"
-
   index = RubyIndexer::Index.new
 
-  result = Benchmark.realtime { index.index_all }
+  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  index.index_all
+  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+
   entries = index.instance_variable_get(:@entries)
   entries_by_entry_type = entries.values.flatten.group_by(&:class)
 
   puts <<~MSG
-    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
+    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{elapsed_time.round(5)} seconds and generated:
     - #{entries_by_entry_type.sort_by { |k, _| k.to_s }.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
   MSG
   return

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

@@ -232,7 +232,7 @@ module RubyIndexer
         next unless ancestor_index && (!existing_entry || ancestor_index < existing_entry_index)
 
         if entry.is_a?(Entry::UnresolvedMethodAlias)
-          resolved_alias = resolve_method_alias(entry, receiver_name)
+          resolved_alias = resolve_method_alias(entry, receiver_name, [])
           hash[entry_name] = [resolved_alias, ancestor_index] if resolved_alias.is_a?(Entry::MethodAlias)
         else
           hash[entry_name] = [entry, ancestor_index]
@@ -394,16 +394,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
-    # Attempts to find methods for a resolved fully qualified receiver name.
+    # Attempts to find methods for a resolved fully qualified receiver name. Do not provide the `seen_names` parameter
+    # as it is used only internally to prevent infinite loops when resolving circular aliases
     # Returns `nil` if the method does not exist on that receiver
     sig do
       params(
         method_name: String,
         receiver_name: String,
+        seen_names: T::Array[String],
         inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name, inherited_only: false)
+    def resolve_method(method_name, receiver_name, seen_names = [], inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
@@ -418,7 +420,7 @@ module RubyIndexer
           when Entry::UnresolvedMethodAlias
             # Resolve aliases lazily as we find them
             if entry.owner&.name == ancestor
-              resolved_alias = resolve_method_alias(entry, receiver_name)
+              resolved_alias = resolve_method_alias(entry, receiver_name, seen_names)
               resolved_alias if resolved_alias.is_a?(Entry::MethodAlias)
             end
           end
@@ -614,6 +616,17 @@ module RubyIndexer
       singleton
     end
 
+    sig do
+      type_parameters(:T).params(
+        path: String,
+        type: T::Class[T.all(T.type_parameter(:T), Entry)],
+      ).returns(T.nilable(T::Array[T.type_parameter(:T)]))
+    end
+    def entries_for(path, type)
+      entries = @files_to_entries[path]
+      entries&.grep(type)
+    end
+
     private
 
     # Runs the registered included hooks
@@ -919,16 +932,21 @@ module RubyIndexer
       params(
         entry: Entry::UnresolvedMethodAlias,
         receiver_name: String,
+        seen_names: T::Array[String],
       ).returns(T.any(Entry::MethodAlias, Entry::UnresolvedMethodAlias))
     end
-    def resolve_method_alias(entry, receiver_name)
-      return entry if entry.new_name == entry.old_name
+    def resolve_method_alias(entry, receiver_name, seen_names)
+      new_name = entry.new_name
+      return entry if new_name == entry.old_name
+      return entry if seen_names.include?(new_name)
+
+      seen_names << new_name
 
-      target_method_entries = resolve_method(entry.old_name, receiver_name)
+      target_method_entries = resolve_method(entry.old_name, receiver_name, seen_names)
       return entry unless target_method_entries
 
       resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
-      original_entries = T.must(@entries[entry.new_name])
+      original_entries = T.must(@entries[new_name])
       original_entries.delete(entry)
       original_entries << resolved_alias
       resolved_alias

data/lib/ruby_indexer/test/index_test.rb

@@ -1822,5 +1822,46 @@ module RubyIndexer
         @index.linearized_ancestors_of("Foo::Child::<Class:Child>"),
       )
     end
+
+    def test_resolving_circular_method_aliases_on_class_reopen
+      index(<<~RUBY)
+        class Foo
+          alias bar ==
+          def ==(other) = true
+        end
+
+        class Foo
+          alias == bar
+        end
+      RUBY
+
+      method = @index.resolve_method("==", "Foo").first
+      assert_kind_of(Entry::Method, method)
+      assert_equal("==", method.name)
+
+      candidates = @index.method_completion_candidates("=", "Foo")
+      assert_equal(["==", "==="], candidates.map(&:name))
+    end
+
+    def test_entries_for
+      index(<<~RUBY)
+        class Foo; end
+
+        module Bar
+          def my_def; end
+          def self.my_singleton_def; end
+        end
+      RUBY
+
+      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
+
+      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
+    end
+
+    def test_entries_for_returns_nil_if_no_matches
+      assert_nil(@index.entries_for("non_existing_file.rb", Entry::Namespace))
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -30,6 +30,8 @@ module RubyLsp
     # Addon instances that have declared a handler to accept file watcher events
     @file_watcher_addons = T.let([], T::Array[Addon])
 
+    AddonNotFoundError = Class.new(StandardError)
+
     class << self
       extend T::Sig
 
@@ -78,11 +80,10 @@ module RubyLsp
         errors
       end
 
-      # Intended for use by tests for addons
       sig { params(addon_name: String).returns(Addon) }
       def get(addon_name)
         addon = addons.find { |addon| addon.name == addon_name }
-        raise "Could not find addon '#{addon_name}'" unless addon
+        raise AddonNotFoundError, "Could not find addon '#{addon_name}'" unless addon
 
         addon
       end

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

@@ -40,6 +40,12 @@ module RubyLsp
       @supports_watching_files = T.let(false, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
       @type_inferrer = T.let(TypeInferrer.new(@index, @experimental_features), TypeInferrer)
+      @addon_settings = T.let({}, T::Hash[String, T.untyped])
+    end
+
+    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    def settings_for_addon(addon_name)
+      @addon_settings[addon_name]
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -119,6 +125,12 @@ module RubyLsp
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @type_inferrer.experimental_features = @experimental_features
 
+      addon_settings = options.dig(:initializationOptions, :addonSettings)
+      if addon_settings
+        addon_settings.transform_keys!(&:to_s)
+        @addon_settings.merge!(addon_settings)
+      end
+
       notifications
     end
 

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

@@ -242,7 +242,7 @@ module RubyLsp
         body = statements.body
         return if body.empty?
 
-        add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
+        add_lines_range(node.location.start_line, body.last.location.end_line)
       end
 
       sig { params(node: Prism::Node).void }

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)
@@ -52,13 +50,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,
@@ -74,7 +65,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 +75,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 +100,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 +134,49 @@ 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))
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
       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)
@@ -267,23 +189,20 @@ module RubyLsp
 
       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))
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
       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))
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
       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))
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
       end
 
       sig { params(node: Prism::LocalVariableTargetNode).void }
@@ -294,15 +213,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 +257,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 +278,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 +286,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/formatting.rb

@@ -58,14 +58,16 @@ module RubyLsp
         formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 
+        lines = @document.source.lines
         size = @document.source.size
+
         return if formatted_text.size == size && formatted_text == @document.source
 
         [
           Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(line: 0, character: 0),
-              end: Interface::Position.new(line: size, character: size),
+              end: Interface::Position.new(line: lines.size, character: 0),
             ),
             new_text: formatted_text,
           ),

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.17
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-20 00:00:00.000000000 Z
+date: 2024-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -28,22 +28,16 @@ dependencies:
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.29.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.29.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement