ruby-lsp 0.11.2 → 0.12.0

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -32,7 +32,7 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
-      ATTR_ACCESSORS = T.let(["attr_reader", "attr_writer", "attr_accessor"].freeze, T::Array[String])
+      ATTR_ACCESSORS = T.let([:attr_reader, :attr_writer, :attr_accessor].freeze, T::Array[Symbol])
 
       class SymbolHierarchyRoot
         extend T::Sig
@@ -49,8 +49,8 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::DocumentSymbol]) }
       attr_reader :_response
 
-      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)
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @_response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
         @stack = T.let(
@@ -60,25 +60,25 @@ module RubyLsp
 
         super
 
-        emitter.register(
+        dispatcher.register(
           self,
-          :on_class,
-          :after_class,
-          :on_call,
-          :on_constant_path_write,
-          :on_constant_write,
-          :on_def,
-          :after_def,
-          :on_module,
-          :after_module,
-          :on_instance_variable_write,
-          :on_class_variable_write,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_call_node_enter,
+          :on_constant_path_write_node_enter,
+          :on_constant_write_node_enter,
+          :on_def_node_enter,
+          :on_def_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+          :on_instance_variable_write_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_document_symbol_listener(@emitter, @message_queue)
+        addon.create_document_symbol_listener(@dispatcher, @message_queue)
       end
 
       # Merges responses from other listeners
@@ -88,8 +88,8 @@ module RubyLsp
         self
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
         @stack << create_document_symbol(
           name: node.constant_path.location.slice,
           kind: Constant::SymbolKind::CLASS,
@@ -98,20 +98,20 @@ module RubyLsp
         )
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def after_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
         @stack.pop
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def on_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
         return unless ATTR_ACCESSORS.include?(node.name) && node.receiver.nil?
 
         arguments = node.arguments
         return unless arguments
 
         arguments.arguments.each do |argument|
-          next unless argument.is_a?(YARP::SymbolNode)
+          next unless argument.is_a?(Prism::SymbolNode)
 
           name = argument.value
           next unless name
@@ -125,8 +125,8 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::ConstantPathWriteNode).void }
-      def on_constant_path_write(node)
+      sig { params(node: Prism::ConstantPathWriteNode).void }
+      def on_constant_path_write_node_enter(node)
         create_document_symbol(
           name: node.target.location.slice,
           kind: Constant::SymbolKind::CONSTANT,
@@ -135,8 +135,8 @@ module RubyLsp
         )
       end
 
-      sig { params(node: YARP::ConstantWriteNode).void }
-      def on_constant_write(node)
+      sig { params(node: Prism::ConstantWriteNode).void }
+      def on_constant_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
           kind: Constant::SymbolKind::CONSTANT,
@@ -145,13 +145,13 @@ module RubyLsp
         )
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def after_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_leave(node)
         @stack.pop
       end
 
-      sig { params(node: YARP::ModuleNode).void }
-      def on_module(node)
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
         @stack << create_document_symbol(
           name: node.constant_path.location.slice,
           kind: Constant::SymbolKind::MODULE,
@@ -160,11 +160,11 @@ module RubyLsp
         )
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         receiver = node.receiver
 
-        if receiver.is_a?(YARP::SelfNode)
+        if receiver.is_a?(Prism::SelfNode)
           name = "self.#{node.name}"
           kind = Constant::SymbolKind::METHOD
         else
@@ -182,13 +182,13 @@ module RubyLsp
         @stack << symbol
       end
 
-      sig { params(node: YARP::ModuleNode).void }
-      def after_module(node)
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
         @stack.pop
       end
 
-      sig { params(node: YARP::InstanceVariableWriteNode).void }
-      def on_instance_variable_write(node)
+      sig { params(node: Prism::InstanceVariableWriteNode).void }
+      def on_instance_variable_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
           kind: Constant::SymbolKind::VARIABLE,
@@ -197,8 +197,8 @@ module RubyLsp
         )
       end
 
-      sig { params(node: YARP::ClassVariableWriteNode).void }
-      def on_class_variable_write(node)
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
           kind: Constant::SymbolKind::VARIABLE,
@@ -213,8 +213,8 @@ module RubyLsp
         params(
           name: String,
           kind: Integer,
-          range_location: YARP::Location,
-          selection_range_location: YARP::Location,
+          range_location: Prism::Location,
+          selection_range_location: Prism::Location,
         ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_location:, selection_range_location:)

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -21,39 +21,40 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
 
-      sig { params(comments: T::Array[YARP::Comment], emitter: EventEmitter, queue: Thread::Queue).void }
-      def initialize(comments, emitter, queue)
-        super(emitter, queue)
+      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher, queue: Thread::Queue).void }
+      def initialize(comments, dispatcher, queue)
+        super(dispatcher, queue)
 
         @_response = T.let([], ResponseType)
-        @requires = T.let([], T::Array[YARP::CallNode])
+        @requires = T.let([], T::Array[Prism::CallNode])
         @finalized_response = T.let(false, T::Boolean)
         @comments = comments
 
-        emitter.register(
+        dispatcher.register(
           self,
-          :on_if,
-          :on_in,
-          :on_rescue,
-          :on_when,
-          :on_interpolated_string,
-          :on_array,
-          :on_block,
-          :on_case,
-          :on_class,
-          :on_module,
-          :on_for,
-          :on_hash,
-          :on_singleton_class,
-          :on_unless,
-          :on_until,
-          :on_while,
-          :on_else,
-          :on_ensure,
-          :on_begin,
-          :on_string_concat,
-          :on_def,
-          :on_call,
+          :on_if_node_enter,
+          :on_in_node_enter,
+          :on_rescue_node_enter,
+          :on_when_node_enter,
+          :on_interpolated_string_node_enter,
+          :on_array_node_enter,
+          :on_block_node_enter,
+          :on_case_node_enter,
+          :on_class_node_enter,
+          :on_module_node_enter,
+          :on_for_node_enter,
+          :on_hash_node_enter,
+          :on_singleton_class_node_enter,
+          :on_unless_node_enter,
+          :on_until_node_enter,
+          :on_while_node_enter,
+          :on_else_node_enter,
+          :on_ensure_node_enter,
+          :on_begin_node_enter,
+          :on_string_concat_node_enter,
+          :on_def_node_enter,
+          :on_call_node_enter,
+          :on_lambda_node_enter,
         )
       end
 
@@ -68,114 +69,114 @@ module RubyLsp
         @_response
       end
 
-      sig { params(node: YARP::IfNode).void }
-      def on_if(node)
+      sig { params(node: Prism::IfNode).void }
+      def on_if_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: YARP::InNode).void }
-      def on_in(node)
+      sig { params(node: Prism::InNode).void }
+      def on_in_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: YARP::RescueNode).void }
-      def on_rescue(node)
+      sig { params(node: Prism::RescueNode).void }
+      def on_rescue_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: YARP::WhenNode).void }
-      def on_when(node)
+      sig { params(node: Prism::WhenNode).void }
+      def on_when_node_enter(node)
         add_statements_range(node)
       end
 
-      sig { params(node: YARP::InterpolatedStringNode).void }
-      def on_interpolated_string(node)
+      sig { params(node: Prism::InterpolatedStringNode).void }
+      def on_interpolated_string_node_enter(node)
         opening_loc = node.opening_loc
         closing_loc = node.closing_loc
 
         add_lines_range(opening_loc.start_line, closing_loc.end_line - 1) if opening_loc && closing_loc
       end
 
-      sig { params(node: YARP::ArrayNode).void }
-      def on_array(node)
+      sig { params(node: Prism::ArrayNode).void }
+      def on_array_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::BlockNode).void }
-      def on_block(node)
+      sig { params(node: Prism::BlockNode).void }
+      def on_block_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::CaseNode).void }
-      def on_case(node)
+      sig { params(node: Prism::CaseNode).void }
+      def on_case_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::ModuleNode).void }
-      def on_module(node)
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::ForNode).void }
-      def on_for(node)
+      sig { params(node: Prism::ForNode).void }
+      def on_for_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::HashNode).void }
-      def on_hash(node)
+      sig { params(node: Prism::HashNode).void }
+      def on_hash_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::SingletonClassNode).void }
-      def on_singleton_class(node)
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::UnlessNode).void }
-      def on_unless(node)
+      sig { params(node: Prism::UnlessNode).void }
+      def on_unless_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::UntilNode).void }
-      def on_until(node)
+      sig { params(node: Prism::UntilNode).void }
+      def on_until_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::WhileNode).void }
-      def on_while(node)
+      sig { params(node: Prism::WhileNode).void }
+      def on_while_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::ElseNode).void }
-      def on_else(node)
+      sig { params(node: Prism::ElseNode).void }
+      def on_else_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::EnsureNode).void }
-      def on_ensure(node)
+      sig { params(node: Prism::EnsureNode).void }
+      def on_ensure_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::BeginNode).void }
-      def on_begin(node)
+      sig { params(node: Prism::BeginNode).void }
+      def on_begin_node_enter(node)
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::StringConcatNode).void }
-      def on_string_concat(node)
-        left = T.let(node.left, YARP::Node)
-        left = left.left while left.is_a?(YARP::StringConcatNode)
+      sig { params(node: Prism::StringConcatNode).void }
+      def on_string_concat_node_enter(node)
+        left = T.let(node.left, Prism::Node)
+        left = left.left while left.is_a?(Prism::StringConcatNode)
 
         add_lines_range(left.location.start_line, node.right.location.end_line - 1)
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         params = node.parameters
         parameter_loc = params&.location
         location = node.location
@@ -189,8 +190,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)
         # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
         # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
         if require?(node)
@@ -202,6 +203,11 @@ module RubyLsp
         add_lines_range(location.start_line, location.end_line - 1)
       end
 
+      sig { params(node: Prism::LambdaNode).void }
+      def on_lambda_node_enter(node)
+        add_simple_range(node)
+      end
+
       private
 
       sig { void }
@@ -233,7 +239,7 @@ module RubyLsp
         @requires.clear
       end
 
-      sig { params(node: YARP::CallNode).returns(T::Boolean) }
+      sig { params(node: Prism::CallNode).returns(T::Boolean) }
       def require?(node)
         message = node.message
         return false unless message == "require" || message == "require_relative"
@@ -244,10 +250,10 @@ module RubyLsp
         arguments = node.arguments&.arguments
         return false unless arguments
 
-        arguments.length == 1 && arguments.first.is_a?(YARP::StringNode)
+        arguments.length == 1 && arguments.first.is_a?(Prism::StringNode)
       end
 
-      sig { params(node: T.any(YARP::IfNode, YARP::InNode, YARP::RescueNode, YARP::WhenNode)).void }
+      sig { params(node: T.any(Prism::IfNode, Prism::InNode, Prism::RescueNode, Prism::WhenNode)).void }
       def add_statements_range(node)
         statements = node.statements
         return unless statements
@@ -258,7 +264,7 @@ module RubyLsp
         add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
       end
 
-      sig { params(node: YARP::Node).void }
+      sig { params(node: Prism::Node).void }
       def add_simple_range(node)
         location = node.location
         add_lines_range(location.start_line, location.end_line - 1)

data/lib/ruby_lsp/requests/hover.rb

@@ -21,12 +21,12 @@ module RubyLsp
 
       ALLOWED_TARGETS = T.let(
         [
-          YARP::CallNode,
-          YARP::ConstantReadNode,
-          YARP::ConstantWriteNode,
-          YARP::ConstantPathNode,
+          Prism::CallNode,
+          Prism::ConstantReadNode,
+          Prism::ConstantWriteNode,
+          Prism::ConstantPathNode,
         ],
-        T::Array[T.class_of(YARP::Node)],
+        T::Array[T.class_of(Prism::Node)],
       )
 
       sig { override.returns(ResponseType) }
@@ -36,22 +36,27 @@ module RubyLsp
         params(
           index: RubyIndexer::Index,
           nesting: T::Array[String],
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, emitter, message_queue)
+      def initialize(index, nesting, dispatcher, message_queue)
         @index = index
         @nesting = nesting
         @_response = T.let(nil, ResponseType)
 
-        super(emitter, message_queue)
-        emitter.register(self, :on_constant_read, :on_constant_write, :on_constant_path)
+        super(dispatcher, message_queue)
+        dispatcher.register(
+          self,
+          :on_constant_read_node_enter,
+          :on_constant_write_node_enter,
+          :on_constant_path_node_enter,
+        )
       end
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_hover_listener(@nesting, @index, @emitter, @message_queue)
+        addon.create_hover_listener(@nesting, @index, @dispatcher, @message_queue)
       end
 
       # Merges responses from other hover listeners
@@ -69,22 +74,22 @@ module RubyLsp
         self
       end
 
-      sig { params(node: YARP::ConstantReadNode).void }
-      def on_constant_read(node)
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
         generate_hover(node.slice, node.location)
       end
 
-      sig { params(node: YARP::ConstantWriteNode).void }
-      def on_constant_write(node)
+      sig { params(node: Prism::ConstantWriteNode).void }
+      def on_constant_write_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: YARP::ConstantPathNode).void }
-      def on_constant_path(node)
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
         generate_hover(node.slice, node.location)
@@ -92,7 +97,7 @@ module RubyLsp
 
       private
 
-      sig { params(name: String, location: YARP::Location).void }
+      sig { params(name: String, location: Prism::Location).void }
       def generate_hover(name, location)
         entries = @index.resolve(name, @nesting)
         return unless entries

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -29,18 +29,18 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(range: T::Range[Integer], emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(range, emitter, message_queue)
-        super(emitter, message_queue)
+      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
+      def initialize(range, dispatcher, message_queue)
+        super(dispatcher, message_queue)
 
         @_response = T.let([], ResponseType)
         @range = range
 
-        emitter.register(self, :on_rescue)
+        dispatcher.register(self, :on_rescue_node_enter)
       end
 
-      sig { params(node: YARP::RescueNode).void }
-      def on_rescue(node)
+      sig { params(node: Prism::RescueNode).void }
+      def on_rescue_node_enter(node)
         return unless node.exceptions.empty?
 
         loc = node.location