ruby-lsp 0.11.2 → 0.12.1

data/lib/ruby_lsp/executor.rb

@@ -92,14 +92,14 @@ module RubyLsp
         return cached_response if cached_response
 
         # Run listeners for the document
-        emitter = EventEmitter.new
-        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, emitter, @message_queue)
-        document_symbol = Requests::DocumentSymbol.new(emitter, @message_queue)
-        document_link = Requests::DocumentLink.new(uri, document.comments, emitter, @message_queue)
-        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue)
+        dispatcher = Prism::Dispatcher.new
+        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher, @message_queue)
+        document_symbol = Requests::DocumentSymbol.new(dispatcher, @message_queue)
+        document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher, @message_queue)
+        code_lens = Requests::CodeLens.new(uri, dispatcher, @message_queue)
 
-        semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
-        emitter.visit(document.tree)
+        semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher, @message_queue)
+        dispatcher.dispatch(document.tree)
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
@@ -210,21 +210,31 @@ module RubyLsp
       # stuck indexing files
       RubyIndexer.configuration.load_config
 
-      begin
-        @index.index_all
-      rescue StandardError => error
-        @message_queue << Notification.new(
-          message: "window/showMessage",
-          params: Interface::ShowMessageParams.new(
-            type: Constant::MessageType::ERROR,
-            message: "Error while indexing: #{error.message}",
-          ),
-        )
-      end
+      Thread.new do
+        begin
+          @index.index_all do |percentage|
+            progress("indexing-progress", percentage)
+            true
+          rescue ClosedQueueError
+            # Since we run indexing on a separate thread, it's possible to kill the server before indexing is complete.
+            # In those cases, the message queue will be closed and raise a ClosedQueueError. By returning `false`, we
+            # tell the index to stop working immediately
+            false
+          end
+        rescue StandardError => error
+          @message_queue << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::ERROR,
+              message: "Error while indexing: #{error.message}",
+            ),
+          )
+        end
 
-      # Always end the progress notification even if indexing failed or else it never goes away and the user has no way
-      # of dismissing it
-      end_progress("indexing-progress")
+        # Always end the progress notification even if indexing failed or else it never goes away and the user has no
+        # way of dismissing it
+        end_progress("indexing-progress")
+      end
     end
 
     sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
@@ -247,20 +257,20 @@ module RubyLsp
       document = @store.get(uri)
       target, parent, nesting = document.locate_node(
         position,
-        node_types: [YARP::CallNode, YARP::ConstantReadNode, YARP::ConstantPathNode],
+        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
       )
 
-      target = parent if target.is_a?(YARP::ConstantReadNode) && parent.is_a?(YARP::ConstantPathNode)
+      target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
 
-      emitter = EventEmitter.new
+      dispatcher = Prism::Dispatcher.new
       base_listener = Requests::Definition.new(
         uri,
         nesting,
         @index,
-        emitter,
+        dispatcher,
         @message_queue,
       )
-      emitter.emit_for_target(target)
+      dispatcher.dispatch_once(target)
       base_listener.response
     end
 
@@ -279,16 +289,16 @@ module RubyLsp
 
       if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
           !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(YARP::ConstantPathNode) && target.is_a?(YARP::ConstantReadNode))
+          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
         target = parent
       end
 
       # Instantiate all listeners
-      emitter = EventEmitter.new
-      hover = Requests::Hover.new(@index, nesting, emitter, @message_queue)
+      dispatcher = Prism::Dispatcher.new
+      hover = Requests::Hover.new(@index, nesting, dispatcher, @message_queue)
 
       # Emit events for all listeners
-      emitter.emit_for_target(target)
+      dispatcher.dispatch_once(target)
 
       hover.response
     end
@@ -367,9 +377,9 @@ module RubyLsp
       document = @store.get(uri)
 
       target, parent = document.locate_node(position)
-      emitter = EventEmitter.new
-      listener = Requests::DocumentHighlight.new(target, parent, emitter, @message_queue)
-      emitter.visit(document.tree)
+      dispatcher = Prism::Dispatcher.new
+      listener = Requests::DocumentHighlight.new(target, parent, dispatcher, @message_queue)
+      dispatcher.visit(document.tree)
       listener.response
     end
 
@@ -380,9 +390,9 @@ module RubyLsp
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
-      emitter = EventEmitter.new
-      listener = Requests::InlayHints.new(start_line..end_line, emitter, @message_queue)
-      emitter.visit(document.tree)
+      dispatcher = Prism::Dispatcher.new
+      listener = Requests::InlayHints.new(start_line..end_line, dispatcher, @message_queue)
+      dispatcher.visit(document.tree)
       listener.response
     end
 
@@ -444,13 +454,13 @@ module RubyLsp
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
-      emitter = EventEmitter.new
+      dispatcher = Prism::Dispatcher.new
       listener = Requests::SemanticHighlighting.new(
-        emitter,
+        dispatcher,
         @message_queue,
         range: start_line..end_line,
       )
-      emitter.visit(document.tree)
+      dispatcher.visit(document.tree)
 
       Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
     end
@@ -471,29 +481,29 @@ module RubyLsp
       # the node, as it could not be a constant
       target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
         char_position -= 1
-        [YARP::ConstantReadNode, YARP::ConstantPathNode]
+        [Prism::ConstantReadNode, Prism::ConstantPathNode]
       else
-        [YARP::CallNode]
+        [Prism::CallNode]
       end
 
       matched, parent, nesting = document.locate(document.tree, char_position, node_types: target_node_types)
       return unless matched && parent
 
       target = case matched
-      when YARP::CallNode
+      when Prism::CallNode
         message = matched.message
         return unless message == "require"
 
         args = matched.arguments&.arguments
-        return if args.nil? || args.is_a?(YARP::ForwardingArgumentsNode)
+        return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
 
         argument = args.first
-        return unless argument.is_a?(YARP::StringNode)
+        return unless argument.is_a?(Prism::StringNode)
         return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
 
         argument
-      when YARP::ConstantReadNode, YARP::ConstantPathNode
-        if parent.is_a?(YARP::ConstantPathNode) && matched.is_a?(YARP::ConstantReadNode)
+      when Prism::ConstantReadNode, Prism::ConstantPathNode
+        if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
           parent
         else
           matched
@@ -502,19 +512,19 @@ module RubyLsp
 
       return unless target
 
-      emitter = EventEmitter.new
+      dispatcher = Prism::Dispatcher.new
       listener = Requests::Completion.new(
         @index,
         nesting,
-        emitter,
+        dispatcher,
         @message_queue,
       )
-      emitter.emit_for_target(target)
+      dispatcher.dispatch_once(target)
       listener.response
     end
 
-    sig { params(id: String, title: String).void }
-    def begin_progress(id, title)
+    sig { params(id: String, title: String, percentage: Integer).void }
+    def begin_progress(id, title, percentage: 0)
       return unless @store.supports_progress
 
       @message_queue << Request.new(
@@ -526,7 +536,29 @@ module RubyLsp
         message: "$/progress",
         params: Interface::ProgressParams.new(
           token: id,
-          value: Interface::WorkDoneProgressBegin.new(kind: "begin", title: title),
+          value: Interface::WorkDoneProgressBegin.new(
+            kind: "begin",
+            title: title,
+            percentage: percentage,
+            message: "#{percentage}% completed",
+          ),
+        ),
+      )
+    end
+
+    sig { params(id: String, percentage: Integer).void }
+    def progress(id, percentage)
+      return unless @store.supports_progress
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressReport.new(
+            kind: "report",
+            percentage: percentage,
+            message: "#{percentage}% completed",
+          ),
         ),
       )
     end
@@ -542,6 +574,9 @@ module RubyLsp
           value: Interface::WorkDoneProgressEnd.new(kind: "end"),
         ),
       )
+    rescue ClosedQueueError
+      # If the server was killed and the message queue is already closed, there's no way to end the progress
+      # notification
     end
 
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
@@ -557,7 +592,8 @@ module RubyLsp
         encodings.first
       end
 
-      @store.supports_progress = options.dig(:capabilities, :window, :workDoneProgress) || true
+      progress = options.dig(:capabilities, :window, :workDoneProgress)
+      @store.supports_progress = progress.nil? ? true : progress
       formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
         DependencyDetector.instance.detected_formatter

data/lib/ruby_lsp/internal.rb

@@ -1,8 +1,14 @@
 # typed: strict
 # frozen_string_literal: true
 
+# If YARP is in the bundle, we have to remove it from the $LOAD_PATH because it contains a default export named `prism`
+# that will conflict with the actual Prism gem
+yarp_require_paths = Gem.loaded_specs["yarp"]&.full_require_paths
+$LOAD_PATH.delete_if { |path| yarp_require_paths.include?(path) } if yarp_require_paths
+
 require "sorbet-runtime"
-require "yarp"
+require "prism"
+require "prism/visitor"
 require "language_server-protocol"
 require "bundler"
 require "uri"
@@ -16,7 +22,6 @@ require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"
-require "ruby_lsp/event_emitter"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
 require "ruby_lsp/store"

data/lib/ruby_lsp/listener.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   # Listener is an abstract class to be used by requests for listening to events emitted when visiting an AST using the
-  # EventEmitter.
+  # Prism::Dispatcher.
   class Listener
     extend T::Sig
     extend T::Helpers
@@ -14,9 +14,9 @@ module RubyLsp
 
     abstract!
 
-    sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
-    def initialize(emitter, message_queue)
-      @emitter = emitter
+    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
+    def initialize(dispatcher, message_queue)
+      @dispatcher = dispatcher
       @message_queue = message_queue
     end
 
@@ -43,8 +43,8 @@ module RubyLsp
     # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
     # ivars have been initialized. This is because the constructor of ExtensibleListener calls
     # `initialize_external_listener` which may depend on the subclass's ivars.
-    sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
-    def initialize(emitter, message_queue)
+    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
+    def initialize(dispatcher, message_queue)
       super
       @response_merged = T.let(false, T::Boolean)
       @external_listeners = T.let(

data/lib/ruby_lsp/requests/base_request.rb

@@ -4,7 +4,7 @@
 module RubyLsp
   module Requests
     # :nodoc:
-    class BaseRequest < YARP::Visitor
+    class BaseRequest < Prism::Visitor
       extend T::Sig
       extend T::Helpers
       include Support::Common
@@ -19,14 +19,6 @@ module RubyLsp
 
       sig { abstract.returns(Object) }
       def run; end
-
-      # YARP implements `visit_all` using `map` instead of `each` for users who want to use the pattern
-      # `result = visitor.visit(tree)`. However, we don't use that pattern and should avoid producing a new array for
-      # every single node visited
-      sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
-      def visit_all(nodes)
-        nodes.each { |node| visit(node) }
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -55,7 +55,7 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         closest_statements, parent_statements = @document
-          .locate(@document.tree, start_index, node_types: [YARP::StatementsNode, YARP::BlockNode])
+          .locate(@document.tree, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
 
@@ -66,11 +66,11 @@ module RubyLsp
           distance <= 0 ? Float::INFINITY : distance
         end)
 
-        return Error::InvalidTargetRange if closest_node.is_a?(YARP::MissingNode)
+        return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
 
         closest_node_loc = closest_node.location
         # If the parent expression is a single line block, then we have to extract it inside of the oneline block
-        if parent_statements.is_a?(YARP::BlockNode) &&
+        if parent_statements.is_a?(Prism::BlockNode) &&
             parent_statements.location.start_line == parent_statements.location.end_line
 
           variable_source = " #{NEW_VARIABLE_NAME} = #{extracted_source};"

data/lib/ruby_lsp/requests/code_lens.rb

@@ -24,37 +24,53 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
 
-      BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
-      ACCESS_MODIFIERS = T.let(["public", "private", "protected"], T::Array[String])
+      BASE_COMMAND = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_lockfile }
+          "bundle exec ruby"
+        rescue Bundler::GemfileNotFound
+          "ruby"
+        end + " -Itest ",
+        String,
+      )
+      GEMFILE_NAME = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
+        rescue Bundler::GemfileNotFound
+          "Gemfile"
+        end,
+        String,
+      )
+      ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
+      def initialize(uri, dispatcher, message_queue)
         @uri = T.let(uri, URI::Generic)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
-        @visibility_stack = T.let([["public", "public"]], T::Array[T::Array[T.nilable(String)]])
+        @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
         @class_stack = T.let([], T::Array[String])
 
-        super(emitter, message_queue)
+        super(dispatcher, message_queue)
 
-        emitter.register(
+        dispatcher.register(
           self,
-          :on_class,
-          :after_class,
-          :on_def,
-          :on_call,
-          :after_call,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_def_node_enter,
+          :on_call_node_enter,
+          :on_call_node_leave,
         )
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
-        @visibility_stack.push(["public", "public"])
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        @visibility_stack.push([:public, :public])
         class_name = node.constant_path.slice
         @class_stack.push(class_name)
 
@@ -68,19 +84,19 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def after_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
         @visibility_stack.pop
         @class_stack.pop
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         class_name = @class_stack.last
         return unless class_name&.end_with?("Test")
 
         visibility, _ = @visibility_stack.last
-        if visibility == "public"
+        if visibility == :public
           method_name = node.name.to_s
           if @path && method_name.start_with?("test_")
             add_test_code_lens(
@@ -93,8 +109,8 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def on_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
         name = node.name
         arguments = node.arguments
 
@@ -103,7 +119,7 @@ module RubyLsp
           if arguments.nil?
             @visibility_stack.pop
             @visibility_stack.push([name, name])
-          elsif arguments.arguments.first.is_a?(YARP::DefNode)
+          elsif arguments.arguments.first.is_a?(Prism::DefNode)
             visibility, _ = @visibility_stack.pop
             @visibility_stack.push([name, visibility])
           end
@@ -111,9 +127,9 @@ module RubyLsp
           return
         end
 
-        if @path&.include?("Gemfile") && name == "gem" && arguments
+        if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
           first_argument = arguments.arguments.first
-          return unless first_argument.is_a?(YARP::StringNode)
+          return unless first_argument.is_a?(Prism::StringNode)
 
           remote = resolve_gem_remote(first_argument)
           return unless remote
@@ -122,15 +138,15 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def after_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_leave(node)
         _, prev_visibility = @visibility_stack.pop
         @visibility_stack.push([prev_visibility, prev_visibility])
       end
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_code_lens_listener(@uri, @emitter, @message_queue)
+        addon.create_code_lens_listener(@uri, @dispatcher, @message_queue)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -141,7 +157,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: YARP::Node, name: String, command: String, kind: Symbol).void }
+      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
         return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
@@ -183,7 +199,7 @@ module RubyLsp
         )
       end
 
-      sig { params(gem_name: YARP::StringNode).returns(T.nilable(String)) }
+      sig { params(gem_name: Prism::StringNode).returns(T.nilable(String)) }
       def resolve_gem_remote(gem_name)
         spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.content }&.to_spec
         return if spec.nil?
@@ -215,7 +231,7 @@ module RubyLsp
         command
       end
 
-      sig { params(node: YARP::CallNode, remote: String).void }
+      sig { params(node: Prism::CallNode, remote: String).void }
       def add_open_gem_remote_code_lens(node, remote)
         @_response << create_code_lens(
           node,