ruby-lsp 0.18.3 → 0.19.0

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -0,0 +1,262 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class ReferenceFinder
+    extend T::Sig
+
+    class Reference
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(Prism::Location) }
+      attr_reader :location
+
+      sig { params(name: String, location: Prism::Location).void }
+      def initialize(name, location)
+        @name = name
+        @location = location
+      end
+    end
+
+    sig { returns(T::Array[Reference]) }
+    attr_reader :references
+
+    sig do
+      params(
+        fully_qualified_name: String,
+        index: RubyIndexer::Index,
+        dispatcher: Prism::Dispatcher,
+      ).void
+    end
+    def initialize(fully_qualified_name, index, dispatcher)
+      @fully_qualified_name = fully_qualified_name
+      @index = index
+      @stack = T.let([], T::Array[String])
+      @references = T.let([], T::Array[Reference])
+
+      dispatcher.register(
+        self,
+        :on_class_node_enter,
+        :on_class_node_leave,
+        :on_module_node_enter,
+        :on_module_node_leave,
+        :on_singleton_class_node_enter,
+        :on_singleton_class_node_leave,
+        :on_def_node_enter,
+        :on_def_node_leave,
+        :on_multi_write_node_enter,
+        :on_constant_path_write_node_enter,
+        :on_constant_path_or_write_node_enter,
+        :on_constant_path_operator_write_node_enter,
+        :on_constant_path_and_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_path_node_enter,
+        :on_constant_read_node_enter,
+        :on_constant_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_and_write_node_enter,
+        :on_constant_operator_write_node_enter,
+      )
+    end
+
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_enter(node)
+      constant_path = node.constant_path
+      name = constant_path.slice
+      nesting = actual_nesting(name)
+
+      if nesting.join("::") == @fully_qualified_name
+        @references << Reference.new(name, constant_path.location)
+      end
+
+      @stack << name
+    end
+
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_enter(node)
+      constant_path = node.constant_path
+      name = constant_path.slice
+      nesting = actual_nesting(name)
+
+      if nesting.join("::") == @fully_qualified_name
+        @references << Reference.new(name, constant_path.location)
+      end
+
+      @stack << name
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::SingletonClassNode).void }
+    def on_singleton_class_node_enter(node)
+      expression = node.expression
+      return unless expression.is_a?(Prism::SelfNode)
+
+      @stack << "<Class:#{@stack.last}>"
+    end
+
+    sig { params(node: Prism::SingletonClassNode).void }
+    def on_singleton_class_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::ConstantPathNode).void }
+    def on_constant_path_node_enter(node)
+      name = constant_name(node)
+      return unless name
+
+      collect_constant_references(name, node.location)
+    end
+
+    sig { params(node: Prism::ConstantReadNode).void }
+    def on_constant_read_node_enter(node)
+      name = constant_name(node)
+      return unless name
+
+      collect_constant_references(name, node.location)
+    end
+
+    sig { params(node: Prism::MultiWriteNode).void }
+    def on_multi_write_node_enter(node)
+      [*node.lefts, *node.rest, *node.rights].each do |target|
+        case target
+        when Prism::ConstantTargetNode, Prism::ConstantPathTargetNode
+          collect_constant_references(target.name.to_s, target.location)
+        end
+      end
+    end
+
+    sig { params(node: Prism::ConstantPathWriteNode).void }
+    def on_constant_path_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    def on_constant_path_or_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    def on_constant_path_operator_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    def on_constant_path_and_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantWriteNode).void }
+    def on_constant_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantOrWriteNode).void }
+    def on_constant_or_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantAndWriteNode).void }
+    def on_constant_and_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    def on_constant_operator_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::DefNode).void }
+    def on_def_node_enter(node)
+      if node.receiver.is_a?(Prism::SelfNode)
+        @stack << "<Class:#{@stack.last}>"
+      end
+    end
+
+    sig { params(node: Prism::DefNode).void }
+    def on_def_node_leave(node)
+      if node.receiver.is_a?(Prism::SelfNode)
+        @stack.pop
+      end
+    end
+
+    private
+
+    sig { params(name: String).returns(T::Array[String]) }
+    def actual_nesting(name)
+      nesting = @stack + [name]
+      corrected_nesting = []
+
+      nesting.reverse_each do |name|
+        corrected_nesting.prepend(name.delete_prefix("::"))
+
+        break if name.start_with?("::")
+      end
+
+      corrected_nesting
+    end
+
+    sig { params(name: String, location: Prism::Location).void }
+    def collect_constant_references(name, location)
+      entries = @index.resolve(name, @stack)
+      return unless entries
+
+      entries.each do |entry|
+        next unless entry.name == @fully_qualified_name
+
+        @references << Reference.new(name, location)
+      end
+    end
+
+    sig do
+      params(
+        node: T.any(
+          Prism::ConstantPathNode,
+          Prism::ConstantReadNode,
+          Prism::ConstantPathTargetNode,
+        ),
+      ).returns(T.nilable(String))
+    end
+    def constant_name(node)
+      node.full_name
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+           Prism::ConstantPathNode::MissingNodesInConstantPathError
+      nil
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -6,6 +6,7 @@ require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
+require "ruby_indexer/lib/ruby_indexer/reference_finder"
 require "ruby_indexer/lib/ruby_indexer/enhancement"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -159,6 +159,17 @@ module RubyIndexer
       assert_entry("Foo::Bar", Entry::Module, "/fake/path/foo.rb:4-2:5-5")
     end
 
+    def test_nested_modules_and_classes_with_multibyte_characters
+      index(<<~RUBY)
+        module A動物
+          class Bねこ; end
+        end
+      RUBY
+
+      assert_entry("A動物", Entry::Module, "/fake/path/foo.rb:0-0:2-3")
+      assert_entry("A動物::Bねこ", Entry::Class, "/fake/path/foo.rb:1-2:1-16")
+    end
+
     def test_nested_modules_and_classes
       index(<<~RUBY)
         module Foo

data/lib/ruby_indexer/test/constant_test.rb

@@ -21,6 +21,14 @@ module RubyIndexer
       assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:6-0:6-7")
     end
 
+    def test_constant_with_multibyte_characters
+      index(<<~RUBY)
+        CONST_💎 = "Ruby"
+      RUBY
+
+      assert_entry("CONST_💎", Entry::Constant, "/fake/path/foo.rb:0-0:0-16")
+    end
+
     def test_constant_or_writes
       index(<<~RUBY)
         FOO ||= 1

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -39,6 +39,7 @@ module RubyIndexer
               location,
               location,
               nil,
+              index.configuration.encoding,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -121,6 +122,7 @@ module RubyIndexer
             location,
             location,
             nil,
+            index.configuration.encoding,
             [],
             Entry::Visibility::PUBLIC,
             owner,

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -25,6 +25,18 @@ module RubyIndexer
       assert_equal("Foo::Bar", owner.name)
     end
 
+    def test_instance_variable_with_multibyte_characters
+      index(<<~RUBY)
+        class Foo
+          def initialize
+            @あ = 1
+          end
+        end
+      RUBY
+
+      assert_entry("@あ", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
+    end
+
     def test_instance_variable_and_write
       index(<<~RUBY)
         module Foo

data/lib/ruby_indexer/test/method_test.rb

@@ -27,6 +27,16 @@ module RubyIndexer
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_method_with_multibyte_characters
+      index(<<~RUBY)
+        class Foo
+          def こんにちは; end
+        end
+      RUBY
+
+      assert_entry("こんにちは", Entry::Method, "/fake/path/foo.rb:1-2:1-16")
+    end
+
     def test_singleton_method_using_self_receiver
       index(<<~RUBY)
         class Foo

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -348,6 +348,14 @@ module RubyIndexer
       assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
     end
 
+    def test_indexing_untyped_functions
+      entries = @index.resolve_method("call", "Method")
+
+      parameters = entries.first.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      assert_instance_of(Entry::ForwardingParameter, parameters.first)
+    end
+
     private
 
     def parse_rbs_methods(rbs, method_name)

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -0,0 +1,86 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class ReferenceFinderTest < Minitest::Test
+    def test_finds_constant_references
+      refs = find_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_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_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
+
+    private
+
+    def find_references(fully_qualified_name, 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(fully_qualified_name, index, dispatcher)
+      dispatcher.visit(parse_result.value)
+      finder.references.uniq(&:location)
+    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
 

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