ruby-lsp 0.18.3 → 0.19.1

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -0,0 +1,242 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class ReferenceFinderTest < Minitest::Test
+    def test_finds_constant_references
+      refs = find_const_references("Foo::Bar", <<~RUBY)
+        module Foo
+          class Bar
+          end
+
+          Bar
+        end
+
+        Foo::Bar
+      RUBY
+
+      assert_equal("Bar", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("Bar", refs[1].name)
+      assert_equal(5, refs[1].location.start_line)
+
+      assert_equal("Foo::Bar", refs[2].name)
+      assert_equal(8, refs[2].location.start_line)
+    end
+
+    def test_finds_constant_references_inside_singleton_contexts
+      refs = find_const_references("Foo::<Class:Foo>::Bar", <<~RUBY)
+        class Foo
+          class << self
+            class Bar
+            end
+
+            Bar
+          end
+        end
+      RUBY
+
+      assert_equal("Bar", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("Bar", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+    end
+
+    def test_finds_top_level_constant_references
+      refs = find_const_references("Bar", <<~RUBY)
+        class Bar
+        end
+
+        class Foo
+          ::Bar
+
+          class << self
+            ::Bar
+          end
+        end
+      RUBY
+
+      assert_equal("Bar", refs[0].name)
+      assert_equal(1, refs[0].location.start_line)
+
+      assert_equal("::Bar", refs[1].name)
+      assert_equal(5, refs[1].location.start_line)
+
+      assert_equal("::Bar", refs[2].name)
+      assert_equal(8, refs[2].location.start_line)
+    end
+
+    def test_finds_method_references
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def baz
+            foo
+          end
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+    end
+
+    def test_does_not_mismatch_on_readers_and_writers
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo` but not `foo=`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_matches_writers
+      refs = find_method_references("foo=", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo=` but not `foo`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo=", refs[0].name)
+      assert_equal(5, refs[0].location.start_line)
+
+      assert_equal("foo=", refs[1].name)
+      assert_equal(9, refs[1].location.start_line)
+    end
+
+    def test_find_inherited_methods
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+        end
+
+        class Baz < Bar
+          super.foo
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+    end
+
+    def test_finds_methods_created_in_mixins
+      refs = find_method_references("foo", <<~RUBY)
+        module Mixin
+          def foo
+          end
+        end
+
+        class Bar
+          include Mixin
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_finds_singleton_methods
+      # The current implementation matches on both `Bar.foo` and `Bar#foo` even though they are different
+
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          class << self
+            def foo
+            end
+          end
+
+          def foo
+          end
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(3, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+
+      assert_equal("foo", refs[2].name)
+      assert_equal(11, refs[2].location.start_line)
+    end
+
+    private
+
+    def find_const_references(const_name, source)
+      target = ReferenceFinder::ConstTarget.new(const_name)
+      find_references(target, source)
+    end
+
+    def find_method_references(method_name, source)
+      target = ReferenceFinder::MethodTarget.new(method_name)
+      find_references(target, source)
+    end
+
+    def find_references(target, source)
+      file_path = "/fake.rb"
+      index = Index.new
+      index.index_single(IndexablePath.new(nil, file_path), source)
+      parse_result = Prism.parse(source)
+      dispatcher = Prism::Dispatcher.new
+      finder = ReferenceFinder.new(target, index, dispatcher)
+      dispatcher.visit(parse_result.value)
+      finder.references
+    end
+  end
+end

data/lib/ruby_lsp/addon.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  # To register an addon, inherit from this class and implement both `name` and `activate`
+  # To register an add-on, inherit from this class and implement both `name` and `activate`
   #
   # # Example
   #
@@ -14,7 +14,7 @@ module RubyLsp
   #     end
   #
   #     def name
-  #       "My addon name"
+  #       "My add-on name"
   #     end
   #   end
   # end
@@ -27,11 +27,13 @@ module RubyLsp
 
     @addons = T.let([], T::Array[Addon])
     @addon_classes = T.let([], T::Array[T.class_of(Addon)])
-    # Addon instances that have declared a handler to accept file watcher events
+    # Add-on instances that have declared a handler to accept file watcher events
     @file_watcher_addons = T.let([], T::Array[Addon])
 
     AddonNotFoundError = Class.new(StandardError)
 
+    class IncompatibleApiError < StandardError; end
+
     class << self
       extend T::Sig
 
@@ -51,15 +53,30 @@ module RubyLsp
         super
       end
 
-      # Discovers and loads all addons. Returns a list of errors when trying to require addons
+      # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
       sig do
-        params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[StandardError])
+        params(
+          global_state: GlobalState,
+          outgoing_queue: Thread::Queue,
+          include_project_addons: T::Boolean,
+        ).returns(T::Array[StandardError])
       end
-      def load_addons(global_state, outgoing_queue)
-        # Require all addons entry points, which should be placed under
-        # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
-        errors = Gem.find_files("ruby_lsp/**/addon.rb").filter_map do |addon|
-          require File.expand_path(addon)
+      def load_addons(global_state, outgoing_queue, include_project_addons: true)
+        # Require all add-ons entry points, which should be placed under
+        # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
+        # `your_project/ruby_lsp/project_name/addon.rb`
+        addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
+
+        if include_project_addons
+          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+        end
+
+        errors = addon_files.filter_map do |addon_path|
+          # Avoid requiring this file twice. This may happen if you're working on the Ruby LSP itself and at the same
+          # time have `ruby-lsp` installed as a vendored gem
+          next if File.basename(File.dirname(addon_path)) == "ruby_lsp"
+
+          require File.expand_path(addon_path)
           nil
         rescue => e
           e
@@ -69,7 +86,7 @@ module RubyLsp
         self.addons = addon_classes.map(&:new)
         self.file_watcher_addons = addons.select { |addon| addon.respond_to?(:workspace_did_change_watched_files) }
 
-        # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
+        # Activate each one of the discovered add-ons. If any problems occur in the add-ons, we don't want to
         # fail to boot the server
         addons.each do |addon|
           addon.activate(global_state, outgoing_queue)
@@ -80,13 +97,53 @@ module RubyLsp
         errors
       end
 
-      sig { params(addon_name: String).returns(Addon) }
-      def get(addon_name)
+      # Get a reference to another add-on object by name and version. If an add-on exports an API that can be used by
+      # other add-ons, this is the way to get access to that API.
+      #
+      # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
+      # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
+      # the responsibility of the add-ons using this API to handle these errors appropriately.
+      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      def get(addon_name, *version_constraints)
+        if version_constraints.empty?
+          raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
+        end
+
         addon = addons.find { |addon| addon.name == addon_name }
-        raise AddonNotFoundError, "Could not find addon '#{addon_name}'" unless addon
+        raise AddonNotFoundError, "Could not find add-on '#{addon_name}'" unless addon
+
+        version_object = Gem::Version.new(addon.version)
+
+        unless version_constraints.all? { |constraint| Gem::Requirement.new(constraint).satisfied_by?(version_object) }
+          raise IncompatibleApiError,
+            "Constraints #{version_constraints.inspect} is incompatible with #{addon_name} version #{addon.version}"
+        end
 
         addon
       end
+
+      # Depend on a specific version of the Ruby LSP. This method should only be used if the add-on is distributed in a
+      # gem that does not have a runtime dependency on the ruby-lsp gem. This method should be invoked at the top of the
+      # `addon.rb` file before defining any classes or requiring any files. For example:
+      #
+      # ```ruby
+      # RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.18.0")
+      #
+      # module MyGem
+      #   class MyAddon < RubyLsp::Addon
+      #     # ...
+      #   end
+      # end
+      # ```
+      sig { params(version_constraints: String).void }
+      def depend_on_ruby_lsp!(*version_constraints)
+        version_object = Gem::Version.new(RubyLsp::VERSION)
+
+        unless version_constraints.all? { |constraint| Gem::Requirement.new(constraint).satisfied_by?(version_object) }
+          raise IncompatibleApiError,
+            "Add-on is not compatible with this version of the Ruby LSP. Skipping its activation"
+        end
+      end
     end
 
     sig { void }
@@ -118,20 +175,25 @@ module RubyLsp
       @errors.map(&:full_message).join("\n\n")
     end
 
-    # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
+    # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
     sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
     def activate(global_state, outgoing_queue); end
 
-    # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
     sig { abstract.void }
     def deactivate; end
 
-    # Addons should override the `name` method to return the addon name
+    # Add-ons should override the `name` method to return the add-on name
     sig { abstract.returns(String) }
     def name; end
 
+    # Add-ons should override the `version` method to return a semantic version string representing the add-on's
+    # version. This is used for compatibility checks
+    sig { abstract.returns(String) }
+    def version; end
+
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
     sig do
       overridable.params(

data/lib/ruby_lsp/base_server.rb

@@ -130,6 +130,12 @@ module RubyLsp
     sig { abstract.void }
     def shutdown; end
 
+    sig { params(id: Integer, message: String, type: Integer).void }
+    def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
+      send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
+      send_message(Notification.window_show_message(message, type: type))
+    end
+
     sig { returns(Thread) }
     def new_worker
       Thread.new do

data/lib/ruby_lsp/erb_document.rb

@@ -27,8 +27,9 @@ module RubyLsp
       scanner = ERBScanner.new(@source)
       scanner.scan
       @host_language_source = scanner.host_language
-      # assigning empty scopes to turn Prism into eval mode
-      @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
+      # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
+      # which they will be evaluated
+      @parse_result = Prism.parse(scanner.ruby, partial_script: true)
       true
     end
 
@@ -49,7 +50,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        node_types: node_types,
+        encoding: @encoding,
+      )
     end
 
     sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }

data/lib/ruby_lsp/global_state.rb

@@ -23,6 +23,9 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files, :experimental_features, :supports_request_delegation
 
+    sig { returns(T::Array[String]) }
+    attr_reader :supported_resource_operations
+
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
 
@@ -42,6 +45,7 @@ module RubyLsp
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
       @supports_request_delegation = T.let(false, T::Boolean)
+      @supported_resource_operations = T.let([], T::Array[String])
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -117,6 +121,7 @@ module RubyLsp
       else
         Encoding::UTF_32
       end
+      @index.configuration.encoding = @encoding
 
       file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
       if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
@@ -132,6 +137,9 @@ module RubyLsp
       end
 
       @supports_request_delegation = options.dig(:capabilities, :experimental, :requestDelegation) || false
+      supported_resource_operations = options.dig(:capabilities, :workspace, :workspaceEdit, :resourceOperations)
+      @supported_resource_operations = supported_resource_operations if supported_resource_operations
+
       notifications
     end
 

data/lib/ruby_lsp/internal.rb

@@ -26,7 +26,8 @@ require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
-require "ruby_lsp/parameter_scope"
+require "ruby_lsp/static_docs"
+require "ruby_lsp/scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"
@@ -74,6 +75,9 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/range_formatting"
+require "ruby_lsp/requests/references"
+require "ruby_lsp/requests/rename"
 require "ruby_lsp/requests/selection_ranges"
 require "ruby_lsp/requests/semantic_highlighting"
 require "ruby_lsp/requests/show_syntax_tree"

data/lib/ruby_lsp/listeners/completion.rb

@@ -438,7 +438,7 @@ module RubyLsp
             text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
             kind: Constant::CompletionItemKind::KEYWORD,
             data: {
-              skip_resolve: true,
+              keyword: true,
             },
           )
         end

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,8 +21,10 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::InterpolatedStringNode,
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
+          Prism::YieldNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -68,9 +70,22 @@ module RubyLsp
           :on_instance_variable_target_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
+          :on_string_node_enter,
+          :on_interpolated_string_node_enter,
+          :on_yield_node_enter,
         )
       end
 
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
+      sig { params(node: Prism::InterpolatedStringNode).void }
+      def on_interpolated_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
@@ -153,8 +168,50 @@ module RubyLsp
         handle_super_node_hover
       end
 
+      sig { params(node: Prism::YieldNode).void }
+      def on_yield_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       private
 
+      sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
+      def generate_heredoc_hover(node)
+        return unless node.heredoc?
+
+        opening_content = node.opening_loc&.slice
+        return unless opening_content
+
+        match = /(<<(?<type>(-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(opening_content)
+        return unless match
+
+        heredoc_delimiter = match.named_captures["delimiter"]
+
+        if heredoc_delimiter
+          message = if match["type"] == "~"
+            "This is a squiggly heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be ignored in the resulting string."
+          else
+            "This is a heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be considered part of the string."
+          end
+
+          @response_builder.push(message, category: :documentation)
+        end
+      end
+
+      sig { params(keyword: String).void }
+      def handle_keyword_documentation(keyword)
+        content = KEYWORD_DOCS[keyword]
+        return unless content
+
+        doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+
+        @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
+        @response_builder.push("[Read more](#{doc_path})", category: :links)
+        @response_builder.push(content, category: :documentation)
+      end
+
       sig { void }
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher