ruby-lsp 0.12.2 → 0.12.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f60569fbb67f1c78fcffed58dbf540cb4e68fe10200841e54cd8a68859cf0de
-  data.tar.gz: 07c4419c763e590e1fbed7fe14a2660c1bf6ddbd92ca791948a8c2235208f6e9
+  metadata.gz: 70a84356e392893c6f7b20e1701ef31621d9902af3a120c7013a13f80ec09568
+  data.tar.gz: bd360c2a5426631816f227ff115af967813ae7284d0a61845daf743b0a99d948
 SHA512:
-  metadata.gz: 5284be197a27351a845cbcfc1735a0e9546472d60f9600ffd4ee55ba3ab0998438110c1ec59f684e0cf2fbaa7ff99f89878919ae3954022372e50116182c59dd
-  data.tar.gz: f706c17b0cd47c1001bffb42f6c9a1c43efbd390e548ffe7b51fb3c58bdb433c868a7f907a3aa32175d7742ccbb3c1c29606a0c7c979246bfe887500e6531676
+  metadata.gz: 598494207add9412e909836e65f6288403189133711dbb17e39663eecc719089dba9f8e758069fda91666715d8c8fc5326055192ba5558f6d8151bbc21f40338
+  data.tar.gz: b86880d5b342e817d8cda46c4977a4229896d19b1fa495c6235f4d86ba74fa1a8ec737b7bad8a19af8859f315980f491b7bd8bcd8f25c1ad21d1ec3f119b9aaf

data/README.md

@@ -52,6 +52,7 @@ The Ruby LSP provides an addon system that allows other gems to enhance the base
 features. This is the mechanism that powers addons like
 
 - [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
+- [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 
 For instructions on how to create addons, see the [addons documentation](ADDONS.md).
 

data/VERSION

@@ -1 +1 @@
-0.12.2
+0.12.4

data/exe/ruby-lsp-doctor

@@ -10,6 +10,6 @@ RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
   content = File.read(indexable.full_path)
   result = Prism.parse(content)
-  visitor = RubyIndexer::IndexVisitor.new(index, result, indexable.full_path)
-  result.value.accept(visitor)
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
 end

data/lib/ruby_indexer/lib/ruby_indexer/{visitor.rb → collector.rb}

@@ -2,9 +2,11 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  class IndexVisitor < Prism::Visitor
+  class Collector
     extend T::Sig
 
+    LEAVE_EVENT = T.let(Object.new.freeze, Object)
+
     sig { params(index: Index, parse_result: Prism::ParseResult, file_path: String).void }
     def initialize(index, parse_result, file_path)
       @index = index
@@ -16,26 +18,67 @@ module RubyIndexer
         end,
         T::Hash[Integer, Prism::Comment],
       )
+      @queue = T.let([], T::Array[Object])
+      @current_owner = T.let(nil, T.nilable(Entry::Namespace))
 
       super()
     end
 
-    sig { override.params(node: Prism::ClassNode).void }
-    def visit_class_node(node)
-      add_class_entry(node)
+    sig { params(node: Prism::Node).void }
+    def collect(node)
+      @queue = [node]
+
+      until @queue.empty?
+        node_or_event = @queue.shift
+
+        case node_or_event
+        when Prism::ProgramNode
+          @queue << node_or_event.statements
+        when Prism::StatementsNode
+          T.unsafe(@queue).prepend(*node_or_event.body)
+        when Prism::ClassNode
+          add_class_entry(node_or_event)
+        when Prism::ModuleNode
+          add_module_entry(node_or_event)
+        when Prism::MultiWriteNode
+          handle_multi_write_node(node_or_event)
+        when Prism::ConstantPathWriteNode
+          handle_constant_path_write_node(node_or_event)
+        when Prism::ConstantPathOrWriteNode
+          handle_constant_path_or_write_node(node_or_event)
+        when Prism::ConstantPathOperatorWriteNode
+          handle_constant_path_operator_write_node(node_or_event)
+        when Prism::ConstantPathAndWriteNode
+          handle_constant_path_and_write_node(node_or_event)
+        when Prism::ConstantWriteNode
+          handle_constant_write_node(node_or_event)
+        when Prism::ConstantOrWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantAndWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantOperatorWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::CallNode
+          handle_call_node(node_or_event)
+        when Prism::DefNode
+          handle_def_node(node_or_event)
+        when LEAVE_EVENT
+          @stack.pop
+        end
+      end
     end
 
-    sig { override.params(node: Prism::ModuleNode).void }
-    def visit_module_node(node)
-      add_module_entry(node)
-    end
+    private
 
-    sig { override.params(node: Prism::MultiWriteNode).void }
-    def visit_multi_write_node(node)
+    sig { params(node: Prism::MultiWriteNode).void }
+    def handle_multi_write_node(node)
       value = node.value
       values = value.is_a?(Prism::ArrayNode) && value.opening_loc ? value.elements : []
 
-      node.targets.each_with_index do |target, i|
+      [*node.lefts, *node.rest, *node.rights].each_with_index do |target, i|
         current_value = values[i]
         # The moment we find a splat on the right hand side of the assignment, we can no longer figure out which value
         # gets assigned to what
@@ -50,8 +93,8 @@ module RubyIndexer
       end
     end
 
-    sig { override.params(node: Prism::ConstantPathWriteNode).void }
-    def visit_constant_path_write_node(node)
+    sig { params(node: Prism::ConstantPathWriteNode).void }
+    def handle_constant_path_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -60,8 +103,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOrWriteNode).void }
-    def visit_constant_path_or_write_node(node)
+    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    def handle_constant_path_or_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -70,8 +113,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOperatorWriteNode).void }
-    def visit_constant_path_operator_write_node(node)
+    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    def handle_constant_path_operator_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -80,8 +123,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathAndWriteNode).void }
-    def visit_constant_path_and_write_node(node)
+    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    def handle_constant_path_and_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -90,50 +133,44 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantWriteNode).void }
-    def visit_constant_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantOrWriteNode).void }
-    def visit_constant_or_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantAndWriteNode).void }
-    def visit_constant_and_write_node(node)
+    sig { params(node: Prism::ConstantWriteNode).void }
+    def handle_constant_write_node(node)
       name = fully_qualify_name(node.name.to_s)
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantOperatorWriteNode).void }
-    def visit_constant_operator_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::CallNode).void }
-    def visit_call_node(node)
+    sig { params(node: Prism::CallNode).void }
+    def handle_call_node(node)
       message = node.message
       handle_private_constant(node) if message == "private_constant"
     end
 
-    sig { override.params(node: Prism::DefNode).void }
-    def visit_def_node(node)
+    sig { params(node: Prism::DefNode).void }
+    def handle_def_node(node)
       method_name = node.name.to_s
       comments = collect_comments(node)
       case node.receiver
       when nil
-        @index << Entry::InstanceMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::InstanceMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       when Prism::SelfNode
-        @index << Entry::SingletonMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::SingletonMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       end
     end
 
-    private
-
     sig { params(node: Prism::CallNode).void }
     def handle_private_constant(node)
       arguments = node.arguments&.arguments
@@ -189,12 +226,12 @@ module RubyIndexer
 
         # If the right hand side is another constant assignment, we need to visit it because that constant has to be
         # indexed too
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
       when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
       else
         Entry::Constant.new(name, @file_path, node.location, comments)
@@ -204,20 +241,26 @@ module RubyIndexer
     sig { params(node: Prism::ModuleNode).void }
     def add_module_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
-
-      @index << Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @current_owner = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @index << @current_owner
       @stack << name
-      visit_child_nodes(node)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::ClassNode).void }
     def add_class_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
 
@@ -227,10 +270,16 @@ module RubyIndexer
         superclass.slice
       end
 
-      @index << Entry::Class.new(fully_qualify_name(name), @file_path, node.location, comments, parent_class)
+      @current_owner = Entry::Class.new(
+        fully_qualify_name(name),
+        @file_path,
+        node.location,
+        comments,
+        parent_class,
+      )
+      @index << @current_owner
       @stack << name
-      visit(node.body)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::Node).returns(T::Array[String]) }
@@ -249,7 +298,7 @@ module RubyIndexer
 
         comment_content.delete_prefix!("#")
         comment_content.delete_prefix!(" ")
-        comments.unshift(comment_content)
+        comments.prepend(comment_content)
       end
 
       comments

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

@@ -71,8 +71,13 @@ module RubyIndexer
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |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 for the entire pattern
-          load_path_entry ||= $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          # 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
+          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
+
           IndexablePath.new(load_path_entry, path)
         end
       end
@@ -144,7 +149,7 @@ module RubyIndexer
         # just ignore if they're missing
       end
 
-      indexables.uniq!
+      indexables.uniq!(&:full_path)
       indexables
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -101,6 +101,9 @@ module RubyIndexer
       sig { returns(T::Array[Parameter]) }
       attr_reader :parameters
 
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
       sig do
         params(
           name: String,
@@ -108,11 +111,13 @@ module RubyIndexer
           location: Prism::Location,
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
+          owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, parameters_node)
+      def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
         super(name, file_path, location, comments)
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
+        @owner = owner
       end
 
       private
@@ -136,8 +141,9 @@ module RubyIndexer
         case node
         when Prism::RequiredParameterNode
           node.name
-        when Prism::RequiredDestructuredParameterNode
-          names = node.parameters.map { |parameter_node| parameter_name(parameter_node) }
+        when Prism::MultiTargetNode
+          names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }
+
           names_with_commas = names.join(", ")
           :"(#{names_with_commas})"
         end

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

@@ -93,8 +93,14 @@ module RubyIndexer
     #   [#<Entry::Class name="Foo::Baz">],
     # ]
     # ```
-    sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
-    def prefix_search(query, nesting)
+    sig { params(query: String, nesting: T.nilable(T::Array[String])).returns(T::Array[T::Array[Entry]]) }
+    def prefix_search(query, nesting = nil)
+      unless nesting
+        results = @entries_tree.search(query)
+        results.uniq!
+        return results
+      end
+
       results = nesting.length.downto(0).flat_map do |i|
         prefix = T.must(nesting[0...i]).join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
@@ -180,8 +186,8 @@ module RubyIndexer
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
       result = Prism.parse(content)
-      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
-      result.value.accept(visitor)
+      collector = Collector.new(self, result, indexable_path.full_path)
+      collector.collect(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
@@ -231,6 +237,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
+    # Attempts to find a given method for a resolved fully qualified receiver name. Returns `nil` if the method does not
+    # exist on that receiver
+    sig { params(method_name: String, receiver_name: String).returns(T.nilable(Entry::Method)) }
+    def resolve_method(method_name, receiver_name)
+      method_entries = T.cast(self[method_name], T.nilable(T::Array[Entry::Method]))
+      owner_entries = self[receiver_name]
+      return unless owner_entries && method_entries
+
+      owner_name = T.must(owner_entries.first).name
+      method_entries.find { |entry| entry.owner&.name == owner_name }
+    end
+
     private
 
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,7 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
-require "ruby_indexer/lib/ruby_indexer/visitor"
+require "ruby_indexer/lib/ruby_indexer/collector"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/index_test.rb

@@ -193,5 +193,58 @@ module RubyIndexer
 
       assert_instance_of(Entry::UnresolvedAlias, entry)
     end
+
+    def test_visitor_does_not_visit_unnecessary_nodes
+      concats = (0...10_000).map do |i|
+        <<~STRING
+          "string#{i}" \\
+        STRING
+      end.join
+
+      index(<<~RUBY)
+        module Foo
+          local_var = #{concats}
+            "final"
+          @class_instance_var = #{concats}
+            "final"
+          @@class_var = #{concats}
+            "final"
+          $global_var = #{concats}
+            "final"
+          CONST = #{concats}
+            "final"
+        end
+      RUBY
+    end
+
+    def test_resolve_method_with_known_receiver
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo::Bar"))
+      assert_equal("baz", entry.name)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_prefix_search_for_methods
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entries = @index.prefix_search("ba")
+      refute_empty(entries)
+
+      entry = T.must(entries.first).first
+      assert_equal("baz", entry.name)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -69,5 +69,19 @@ module RubyIndexer
       assert_equal(:"(a, (b, ))", parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
+
+    def test_keeps_track_of_method_owner
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      owner_name = T.must(entry.owner).name
+
+      assert_equal("Foo", owner_name)
+    end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -4,6 +4,9 @@
 module RubyLsp
   class Document
     extend T::Sig
+    extend T::Helpers
+
+    abstract!
 
     PositionShape = T.type_alias { { line: Integer, character: Integer } }
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
@@ -28,8 +31,8 @@ module RubyLsp
       @source = T.let(source, String)
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(false, T::Boolean)
-      @parse_result = T.let(Prism.parse(@source), Prism::ParseResult)
+      @needs_parsing = T.let(true, T::Boolean)
+      @parse_result = T.let(parse, Prism::ParseResult)
     end
 
     sig { returns(Prism::ProgramNode) }
@@ -91,13 +94,8 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { void }
-    def parse
-      return unless @needs_parsing
-
-      @needs_parsing = false
-      @parse_result = Prism.parse(@source)
-    end
+    sig { abstract.returns(Prism::ParseResult) }
+    def parse; end
 
     sig { returns(T::Boolean) }
     def syntax_error?

data/lib/ruby_lsp/executor.rb

@@ -57,6 +57,8 @@ module RubyLsp
           warn(errored_addons.map(&:backtraces).join("\n\n"))
         end
 
+        RubyVM::YJIT.enable if defined? RubyVM::YJIT.enable
+
         perform_initial_indexing
         check_formatter_is_available
 
@@ -474,34 +476,32 @@ module RubyLsp
     def completion(uri, position)
       document = @store.get(uri)
 
-      char_position = document.create_scanner.find_char_position(position)
-
-      # When the user types in the first letter of a constant name, we actually receive the position of the next
-      # immediate character. We check to see if the character is uppercase and then remove the offset to try to locate
-      # the node, as it could not be a constant
-      target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
-        char_position -= 1
-        [Prism::ConstantReadNode, Prism::ConstantPathNode]
-      else
-        [Prism::CallNode]
-      end
-
-      matched, parent, nesting = document.locate(document.tree, char_position, node_types: target_node_types)
+      # Completion always receives the position immediately after the character that was just typed. Here we adjust it
+      # back by 1, so that we find the right node
+      char_position = document.create_scanner.find_char_position(position) - 1
+      matched, parent, nesting = document.locate(
+        document.tree,
+        char_position,
+        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+      )
       return unless matched && parent
 
       target = case matched
       when Prism::CallNode
         message = matched.message
-        return unless message == "require"
 
-        args = matched.arguments&.arguments
-        return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
+        if message == "require"
+          args = matched.arguments&.arguments
+          return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
 
-        argument = args.first
-        return unless argument.is_a?(Prism::StringNode)
-        return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
+          argument = args.first
+          return unless argument.is_a?(Prism::StringNode)
+          return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
 
-        argument
+          argument
+        else
+          matched
+        end
       when Prism::ConstantReadNode, Prism::ConstantPathNode
         if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
           parent
@@ -579,7 +579,7 @@ module RubyLsp
       # notification
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
     def initialize_request(options)
       @store.clear
 
@@ -680,7 +680,7 @@ module RubyLsp
       completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
-          trigger_characters: ["/", *"A".."Z"],
+          trigger_characters: ["/"],
           completion_item: {
             labelDetailsSupport: true,
           },
@@ -716,7 +716,7 @@ module RubyLsp
 
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
-      Interface::InitializeResult.new(
+      {
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
@@ -740,7 +740,12 @@ module RubyLsp
           definition_provider: enabled_features["definition"],
           workspace_symbol_provider: enabled_features["workspaceSymbol"],
         ),
-      )
+        serverInfo: {
+          name: "Ruby LSP",
+          version: VERSION,
+        },
+        formatter: @store.formatter,
+      }
     end
 
     sig { void }

data/lib/ruby_lsp/internal.rb

@@ -24,6 +24,10 @@ require "ruby_lsp/server"
 require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
+require "ruby_lsp/document"
+require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+
+Bundler.ui.level = :silent