ruby-lsp 0.17.14 → 0.17.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17c576dbc88c8c4012eb777b15df7df630a827d7692f6bceec06b68178b25357
-  data.tar.gz: f023f22a818616b1c8c6fb1de77d0637e7bdae37b60b46e941b297aaa95729a9
+  metadata.gz: fc4416ea8876d8207b6c1955cd47af5f3312a0f0dc3644563bfd35138a903535
+  data.tar.gz: 5961dd8ca49539c20049509c0afed8b2442c3d16ec12d1fb84c9e45dbd027760
 SHA512:
-  metadata.gz: e0848d63fef1677ccf276182cdea5a8304e4a1e04a7ec4936f8f083c27bc62f575fe3f0a207f75805cf3c8eb106e43d5d1afe2df366028980cb5eee6ed97c14b
-  data.tar.gz: d57869c1ee7dcec65becd9ee4fc225c91e946e697c3aab8a42d2453c1a85bcc91cd8e0a6364d810f8109c2b97102f101d24bf8986d2e4b3905b56368e260b0d3
+  metadata.gz: 4b77547221c1750871ff6e1a3635b0ae6f945b86862f484d20eb7587a1feb9830e1d1d7770f16c2e7efeb70e6a953529041f8acc8fe3d7c30940687d20563f96
+  data.tar.gz: 1093a1a6ac45e8627f26a6c9dbb0017079d2804904fe9a4303e3698d4131c6eeedf2bbafac93e6475f676860624b9c53d482c52cfe8380e67ed05ce525e99957

data/VERSION

@@ -1 +1 @@
-0.17.14
+0.17.16

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

@@ -16,15 +16,24 @@ module RubyIndexer
       T::Hash[String, T.untyped],
     )
 
+    sig { params(workspace_path: String).void }
+    attr_writer :workspace_path
+
     sig { void }
     def initialize
+      @workspace_path = T.let(Dir.pwd, String)
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("**", "tmp", "**", "*")], T::Array[String])
+      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("tmp", "**", "*")], T::Array[String])
+
       path = Bundler.settings["path"]
-      @excluded_patterns << File.join(File.expand_path(path, Dir.pwd), "**", "*.rb") if path
+      if path
+        # Substitute Windows backslashes into forward slashes, which are used in glob patterns
+        glob = path.gsub(/[\\]+/, "/")
+        @excluded_patterns << File.join(glob, "**", "*.rb")
+      end
 
-      @included_patterns = T.let([File.join(Dir.pwd, "**", "*.rb")], T::Array[String])
+      @included_patterns = T.let([File.join("**", "*.rb")], T::Array[String])
       @excluded_magic_comments = T.let(
         [
           "frozen_string_literal:",
@@ -55,12 +64,12 @@ module RubyIndexer
       indexables = @included_patterns.flat_map do |pattern|
         load_path_entry = T.let(nil, T.nilable(String))
 
-        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+        Dir.glob(File.join(@workspace_path, 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
-          # each one of them belongs to a different $LOAD_PATH entry
+          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the current
+          # workspace directory, but each one of them belongs to a different $LOAD_PATH entry
           if load_path_entry.nil? || !path.start_with?(load_path_entry)
             load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
           end
@@ -69,9 +78,19 @@ module RubyIndexer
         end
       end
 
+      # If the patterns are relative, we make it relative to the workspace path. If they are absolute, then we shouldn't
+      # concatenate anything
+      excluded_patterns = @excluded_patterns.map do |pattern|
+        if File.absolute_path?(pattern)
+          pattern
+        else
+          File.join(@workspace_path, pattern)
+        end
+      end
+
       # Remove user specified patterns
       indexables.reject! do |indexable|
-        @excluded_patterns.any? do |pattern|
+        excluded_patterns.any? do |pattern|
           File.fnmatch?(pattern, indexable.full_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
         end
       end
@@ -122,7 +141,7 @@ module RubyIndexer
         # When working on a gem, it will be included in the locked_gems list. Since these are the project's own files,
         # we have already included and handled exclude patterns for it and should not re-include or it'll lead to
         # duplicates or accidentally ignoring exclude patterns
-        next if spec.full_gem_path == Dir.pwd
+        next if spec.full_gem_path == @workspace_path
 
         indexables.concat(
           spec.require_paths.flat_map do |require_path|
@@ -185,7 +204,7 @@ module RubyIndexer
       # If the dependency is prerelease, `to_spec` may return `nil` due to a bug in older version of Bundler/RubyGems:
       # https://github.com/Shopify/ruby-lsp/issues/1246
       this_gem = Bundler.definition.dependencies.find do |d|
-        d.to_spec&.full_gem_path == Dir.pwd
+        d.to_spec&.full_gem_path == @workspace_path
       rescue Gem::MissingSpecError
         false
       end

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

@@ -152,16 +152,17 @@ module RubyIndexer
 
       if current_owner
         expression = node.expression
-        @stack << (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
+        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
+        real_nesting = actual_nesting(name)
 
-        existing_entries = T.cast(@index[@stack.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
+        existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
 
         if existing_entries
           entry = T.must(existing_entries.first)
           entry.update_singleton_information(node.location, expression.location, collect_comments(node))
         else
           entry = Entry::SingletonClass.new(
-            @stack,
+            real_nesting,
             @file_path,
             node.location,
             expression.location,
@@ -172,6 +173,7 @@ module RubyIndexer
         end
 
         @owner_stack << entry
+        @stack << name
       end
     end
 

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -564,6 +564,27 @@ module RubyIndexer
       assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_indexing_singletons_inside_top_level_references
+      index(<<~RUBY)
+        module ::Foo
+          class Bar
+            class << self
+            end
+          end
+        end
+      RUBY
+
+      # We want to explicitly verify that we didn't introduce the leading `::` by accident, but `Index#[]` deletes the
+      # prefix when we use `refute_entry`
+      entries = @index.instance_variable_get(:@entries)
+      refute(entries.key?("::Foo"))
+      refute(entries.key?("::Foo::Bar"))
+      refute(entries.key?("::Foo::Bar::<Class:Bar>"))
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:5-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:4-5")
+      assert_entry("Foo::Bar::<Class:Bar>", Entry::SingletonClass, "/fake/path/foo.rb:2-4:3-7")
+    end
+
     def test_indexing_namespaces_inside_nested_top_level_references
       index(<<~RUBY)
         class Baz

data/lib/ruby_indexer/test/configuration_test.rb

@@ -7,10 +7,12 @@ module RubyIndexer
   class ConfigurationTest < Minitest::Test
     def setup
       @config = Configuration.new
+      @workspace_path = File.expand_path(File.join("..", "..", ".."), __dir__)
+      @config.workspace_path = @workspace_path
     end
 
     def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/test/fixtures/**/*.rb"] })
+      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
       indexables = @config.indexables
 
       assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
@@ -25,7 +27,7 @@ module RubyIndexer
       indexables = @config.indexables
 
       # All paths should be expanded
-      assert(indexables.none? { |indexable| indexable.full_path.start_with?("lib/") })
+      assert(indexables.all? { |indexable| File.absolute_path?(indexable.full_path) })
     end
 
     def test_indexables_only_includes_gem_require_paths
@@ -71,17 +73,20 @@ module RubyIndexer
       Bundler.settings.temporary(path: "vendor/bundle") do
         config = Configuration.new
 
-        assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
+        assert_includes(config.instance_variable_get(:@excluded_patterns), "vendor/bundle/**/*.rb")
       end
     end
 
     def test_indexables_does_not_include_gems_own_installed_files
       indexables = @config.indexables
+      indexables_inside_bundled_lsp = indexables.select do |indexable|
+        indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
+      end
 
-      assert(
-        indexables.none? do |indexable|
-          indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
-        end,
+      assert_empty(
+        indexables_inside_bundled_lsp,
+        "Indexables should not include files from the gem currently being worked on. " \
+          "Included: #{indexables_inside_bundled_lsp.map(&:full_path)}",
       )
     end
 
@@ -126,5 +131,34 @@ module RubyIndexer
         assert_match(regex, comment)
       end
     end
+
+    def test_indexables_respect_given_workspace_path
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir(File.join(dir, "ignore"))
+        FileUtils.touch(File.join(dir, "ignore", "file0.rb"))
+        FileUtils.touch(File.join(dir, "file1.rb"))
+        FileUtils.touch(File.join(dir, "file2.rb"))
+
+        @config.apply_config({ "excluded_patterns" => ["ignore/**/*.rb"] })
+        @config.workspace_path = dir
+        indexables = @config.indexables
+
+        assert(indexables.none? { |indexable| indexable.full_path.start_with?(File.join(dir, "ignore")) })
+
+        # After switching the workspace path, all indexables will be found in one of these places:
+        # - The new workspace path
+        # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
+        # - Bundled gems
+        # - Default gems
+        assert(
+          indexables.all? do |i|
+            i.full_path.start_with?(dir) ||
+            i.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
+            i.full_path.start_with?(Bundler.bundle_path.to_s) ||
+            i.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+          end,
+        )
+      end
+    end
   end
 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/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/definition.rb

@@ -208,10 +208,13 @@ module RubyLsp
       def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
           @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
-        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
+
+        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates,
+        # then we provide a few candidates to jump to
+        # But we don't want to provide too many candidates, as it can be overwhelming
+        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && methods.nil?)
+          methods = @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
         end
 
         return unless methods
@@ -250,7 +253,7 @@ module RubyLsp
         when :require_relative
           required_file = "#{node.content}.rb"
           path = @uri.to_standardized_path
-          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
+          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : @global_state.workspace_path
           candidate = File.expand_path(File.join(current_folder, required_file))
 
           @response_builder << Interface::Location.new(

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 }
@@ -879,7 +941,7 @@ module RubyLsp
         # Indexing produces a high number of short lived object allocations. That might lead to some fragmentation and
         # an unnecessarily expanded heap. Compacting ensures that the heap is as small as possible and that future
         # allocations and garbage collections are faster
-        GC.compact
+        GC.compact unless @test_mode
 
         # Always end the progress notification even if indexing failed or else it never goes away and the user has no
         # way of dismissing it
@@ -1000,10 +1062,10 @@ module RubyLsp
 
       return unless indexing_options
 
+      configuration = @global_state.index.configuration
+      configuration.workspace_path = @global_state.workspace_path
       # The index expects snake case configurations, but VS Code standardizes on camel case settings
-      @global_state.index.configuration.apply_config(
-        indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase },
-      )
+      configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -43,7 +43,7 @@ module RubyLsp
       @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
 
       # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
+      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(@project_path), Pathname)
       @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
       @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
@@ -183,14 +183,14 @@ module RubyLsp
       # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
       # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
       path = Bundler.settings["path"]
-      expanded_path = File.expand_path(path, Dir.pwd) if path
+      expanded_path = File.expand_path(path, @project_path) if path
 
       # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
       env = {}
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
       env["BUNDLE_PATH"] = expanded_path if expanded_path
 
-      local_config_path = File.join(Dir.pwd, ".bundle")
+      local_config_path = File.join(@project_path, ".bundle")
       env["BUNDLE_APP_CONFIG"] = local_config_path if Dir.exist?(local_config_path)
 
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
@@ -286,7 +286,7 @@ module RubyLsp
     sig { returns(T::Boolean) }
     def rails_app?
       config = Pathname.new("config/application.rb").expand_path
-      application_contents = config.read if config.exist?
+      application_contents = config.read(external_encoding: Encoding::UTF_8) if config.exist?
       return false unless application_contents
 
       /class .* < (::)?Rails::Application/.match?(application_contents)

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.14
+  version: 0.17.16
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-19 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol