ruby-lsp 0.11.1 → 0.12.0

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -27,19 +27,97 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
 
+      GLOBAL_VARIABLE_NODES = T.let(
+        [
+          Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableReadNode,
+          Prism::GlobalVariableTargetNode,
+          Prism::GlobalVariableWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
+      INSTANCE_VARIABLE_NODES = T.let(
+        [
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableReadNode,
+          Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
+      CONSTANT_NODES = T.let(
+        [
+          Prism::ConstantAndWriteNode,
+          Prism::ConstantOperatorWriteNode,
+          Prism::ConstantOrWriteNode,
+          Prism::ConstantReadNode,
+          Prism::ConstantTargetNode,
+          Prism::ConstantWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
+      CONSTANT_PATH_NODES = T.let(
+        [
+          Prism::ConstantPathAndWriteNode,
+          Prism::ConstantPathNode,
+          Prism::ConstantPathOperatorWriteNode,
+          Prism::ConstantPathOrWriteNode,
+          Prism::ConstantPathTargetNode,
+          Prism::ConstantPathWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
+      CLASS_VARIABLE_NODES = T.let(
+        [
+          Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode,
+          Prism::ClassVariableReadNode,
+          Prism::ClassVariableTargetNode,
+          Prism::ClassVariableWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
+      LOCAL_NODES = T.let(
+        [
+          Prism::LocalVariableAndWriteNode,
+          Prism::LocalVariableOperatorWriteNode,
+          Prism::LocalVariableOrWriteNode,
+          Prism::LocalVariableReadNode,
+          Prism::LocalVariableTargetNode,
+          Prism::LocalVariableWriteNode,
+          Prism::BlockParameterNode,
+          Prism::RequiredParameterNode,
+          Prism::KeywordParameterNode,
+          Prism::RestParameterNode,
+          Prism::OptionalParameterNode,
+          Prism::KeywordRestParameterNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
+
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
       sig do
         params(
-          target: T.nilable(YARP::Node),
-          parent: T.nilable(YARP::Node),
-          emitter: EventEmitter,
+          target: T.nilable(Prism::Node),
+          parent: T.nilable(Prism::Node),
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(target, parent, emitter, message_queue)
-        super(emitter, message_queue)
+      def initialize(target, parent, dispatcher, message_queue)
+        super(dispatcher, message_queue)
 
         @_response = T.let([], T::Array[Interface::DocumentHighlight])
 
@@ -47,42 +125,441 @@ module RubyLsp
 
         highlight_target =
           case target
-          when YARP::GlobalVariableReadNode, YARP::GlobalVariableAndWriteNode, YARP::GlobalVariableOperatorWriteNode,
-            YARP::GlobalVariableOrWriteNode, YARP::GlobalVariableTargetNode, YARP::GlobalVariableWriteNode,
-            YARP::InstanceVariableAndWriteNode, YARP::InstanceVariableOperatorWriteNode,
-            YARP::InstanceVariableOrWriteNode, YARP::InstanceVariableReadNode, YARP::InstanceVariableTargetNode,
-            YARP::InstanceVariableWriteNode, YARP::ConstantAndWriteNode, YARP::ConstantOperatorWriteNode,
-            YARP::ConstantOrWriteNode, YARP::ConstantPathAndWriteNode, YARP::ConstantPathNode,
-            YARP::ConstantPathOperatorWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathTargetNode,
-            YARP::ConstantPathWriteNode, YARP::ConstantReadNode, YARP::ConstantTargetNode, YARP::ConstantWriteNode,
-            YARP::ClassVariableAndWriteNode, YARP::ClassVariableOperatorWriteNode, YARP::ClassVariableOrWriteNode,
-            YARP::ClassVariableReadNode, YARP::ClassVariableTargetNode, YARP::ClassVariableWriteNode,
-            YARP::LocalVariableAndWriteNode, YARP::LocalVariableOperatorWriteNode, YARP::LocalVariableOrWriteNode,
-            YARP::LocalVariableReadNode, YARP::LocalVariableTargetNode, YARP::LocalVariableWriteNode, YARP::CallNode,
-            YARP::BlockParameterNode, YARP::KeywordParameterNode, YARP::KeywordRestParameterNode,
-            YARP::OptionalParameterNode, YARP::RequiredParameterNode, YARP::RestParameterNode
-            Support::HighlightTarget.new(target)
+          when Prism::GlobalVariableReadNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode, Prism::GlobalVariableWriteNode,
+            Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode,
+            Prism::ConstantOrWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathNode,
+            Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathTargetNode,
+            Prism::ConstantPathWriteNode, Prism::ConstantReadNode, Prism::ConstantTargetNode, Prism::ConstantWriteNode,
+            Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode, Prism::ClassVariableWriteNode,
+            Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+            Prism::LocalVariableReadNode, Prism::LocalVariableTargetNode, Prism::LocalVariableWriteNode,
+            Prism::CallNode, Prism::BlockParameterNode, Prism::KeywordParameterNode, Prism::KeywordRestParameterNode,
+            Prism::OptionalParameterNode, Prism::RequiredParameterNode, Prism::RestParameterNode
+            target
           end
 
-        @target = T.let(highlight_target, T.nilable(Support::HighlightTarget))
+        @target = T.let(highlight_target, T.nilable(Prism::Node))
+        @target_value = T.let(node_value(highlight_target), T.nilable(String))
+
+        if @target && @target_value
+          dispatcher.register(
+            self,
+            :on_call_node_enter,
+            :on_def_node_enter,
+            :on_global_variable_target_node_enter,
+            :on_instance_variable_target_node_enter,
+            :on_constant_path_target_node_enter,
+            :on_constant_target_node_enter,
+            :on_class_variable_target_node_enter,
+            :on_local_variable_target_node_enter,
+            :on_block_parameter_node_enter,
+            :on_required_parameter_node_enter,
+            :on_class_node_enter,
+            :on_module_node_enter,
+            :on_local_variable_read_node_enter,
+            :on_constant_path_node_enter,
+            :on_constant_read_node_enter,
+            :on_instance_variable_read_node_enter,
+            :on_class_variable_read_node_enter,
+            :on_global_variable_read_node_enter,
+            :on_constant_path_write_node_enter,
+            :on_constant_path_or_write_node_enter,
+            :on_constant_path_and_write_node_enter,
+            :on_constant_path_operator_write_node_enter,
+            :on_local_variable_write_node_enter,
+            :on_keyword_parameter_node_enter,
+            :on_rest_parameter_node_enter,
+            :on_optional_parameter_node_enter,
+            :on_keyword_rest_parameter_node_enter,
+            :on_local_variable_and_write_node_enter,
+            :on_local_variable_operator_write_node_enter,
+            :on_local_variable_or_write_node_enter,
+            :on_class_variable_write_node_enter,
+            :on_class_variable_or_write_node_enter,
+            :on_class_variable_operator_write_node_enter,
+            :on_class_variable_and_write_node_enter,
+            :on_constant_write_node_enter,
+            :on_constant_or_write_node_enter,
+            :on_constant_operator_write_node_enter,
+            :on_instance_variable_write_node_enter,
+            :on_constant_and_write_node_enter,
+            :on_instance_variable_or_write_node_enter,
+            :on_instance_variable_and_write_node_enter,
+            :on_instance_variable_operator_write_node_enter,
+            :on_global_variable_write_node_enter,
+            :on_global_variable_or_write_node_enter,
+            :on_global_variable_and_write_node_enter,
+            :on_global_variable_operator_write_node_enter,
+          )
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return unless matches?(node, [Prism::CallNode, Prism::DefNode])
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
+        return unless matches?(node, [Prism::CallNode, Prism::DefNode])
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      def on_global_variable_target_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      def on_instance_variable_target_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::ConstantPathTargetNode).void }
+      def on_constant_path_target_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::ConstantTargetNode).void }
+      def on_constant_target_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::LocalVariableTargetNode).void }
+      def on_local_variable_target_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::BlockParameterNode).void }
+      def on_block_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::RequiredParameterNode).void }
+      def on_required_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.location)
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ClassNode])
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ModuleNode])
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
+      end
+
+      sig { params(node: Prism::LocalVariableReadNode).void }
+      def on_local_variable_read_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::InstanceVariableReadNode).void }
+      def on_instance_variable_read_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::GlobalVariableReadNode).void }
+      def on_global_variable_read_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+      end
+
+      sig { params(node: Prism::ConstantPathWriteNode).void }
+      def on_constant_path_write_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.target.location)
+      end
+
+      sig { params(node: Prism::ConstantPathOrWriteNode).void }
+      def on_constant_path_or_write_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.target.location)
+      end
+
+      sig { params(node: Prism::ConstantPathAndWriteNode).void }
+      def on_constant_path_and_write_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.target.location)
+      end
+
+      sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+      def on_constant_path_operator_write_node_enter(node)
+        return unless matches?(node, CONSTANT_PATH_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.target.location)
+      end
+
+      sig { params(node: Prism::LocalVariableWriteNode).void }
+      def on_local_variable_write_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::KeywordParameterNode).void }
+      def on_keyword_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
 
-        emitter.register(self, :on_node) if @target
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
-      sig { params(node: T.nilable(YARP::Node)).void }
-      def on_node(node)
-        return if node.nil?
+      sig { params(node: Prism::RestParameterNode).void }
+      def on_rest_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
 
-        match = T.must(@target).highlight_type(node)
-        add_highlight(match) if match
+        name_loc = node.name_loc
+        add_highlight(Constant::DocumentHighlightKind::WRITE, name_loc) if name_loc
+      end
+
+      sig { params(node: Prism::OptionalParameterNode).void }
+      def on_optional_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::KeywordRestParameterNode).void }
+      def on_keyword_rest_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        name_loc = node.name_loc
+        add_highlight(Constant::DocumentHighlightKind::WRITE, name_loc) if name_loc
+      end
+
+      sig { params(node: Prism::LocalVariableAndWriteNode).void }
+      def on_local_variable_and_write_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      def on_local_variable_operator_write_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      def on_local_variable_or_write_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        return unless matches?(node, CLASS_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ConstantWriteNode).void }
+      def on_constant_write_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ConstantOrWriteNode).void }
+      def on_constant_or_write_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ConstantOperatorWriteNode).void }
+      def on_constant_operator_write_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableWriteNode).void }
+      def on_instance_variable_write_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      def on_instance_variable_or_write_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      def on_instance_variable_and_write_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      def on_instance_variable_operator_write_node_enter(node)
+        return unless matches?(node, INSTANCE_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::ConstantAndWriteNode).void }
+      def on_constant_and_write_node_enter(node)
+        return unless matches?(node, CONSTANT_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      def on_global_variable_write_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      def on_global_variable_or_write_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      def on_global_variable_and_write_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      def on_global_variable_operator_write_node_enter(node)
+        return unless matches?(node, GLOBAL_VARIABLE_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
       private
 
-      sig { params(match: Support::HighlightTarget::HighlightMatch).void }
-      def add_highlight(match)
-        range = range_from_location(match.location)
-        @_response << Interface::DocumentHighlight.new(range: range, kind: match.type)
+      sig { params(node: Prism::Node, classes: T::Array[T.class_of(Prism::Node)]).returns(T.nilable(T::Boolean)) }
+      def matches?(node, classes)
+        classes.any? { |klass| @target.is_a?(klass) } && @target_value == node_value(node)
+      end
+
+      sig { params(kind: Integer, location: Prism::Location).void }
+      def add_highlight(kind, location)
+        @_response << Interface::DocumentHighlight.new(range: range_from_location(location), kind: kind)
+      end
+
+      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(String)) }
+      def node_value(node)
+        case node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::BlockArgumentNode, Prism::ConstantTargetNode,
+          Prism::ConstantPathWriteNode, Prism::ConstantPathTargetNode, Prism::ConstantPathOrWriteNode,
+          Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathAndWriteNode
+          node.slice
+        when Prism::GlobalVariableReadNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode, Prism::GlobalVariableWriteNode,
+          Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode,
+          Prism::ConstantOrWriteNode, Prism::ConstantWriteNode, Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode,
+          Prism::ClassVariableTargetNode, Prism::ClassVariableWriteNode, Prism::LocalVariableAndWriteNode,
+          Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode, Prism::LocalVariableReadNode,
+          Prism::LocalVariableTargetNode, Prism::LocalVariableWriteNode, Prism::DefNode, Prism::BlockParameterNode,
+          Prism::KeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredParameterNode, Prism::RestParameterNode
+
+          node.name.to_s
+        when Prism::CallNode
+          node.message
+        when Prism::ClassNode, Prism::ModuleNode
+          node.constant_path.slice
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -78,13 +78,13 @@ module RubyLsp
       sig do
         params(
           uri: URI::Generic,
-          comments: T::Array[YARP::Comment],
-          emitter: EventEmitter,
+          comments: T::Array[Prism::Comment],
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, comments, emitter, message_queue)
-        super(emitter, message_queue)
+      def initialize(uri, comments, dispatcher, message_queue)
+        super(dispatcher, message_queue)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
@@ -96,40 +96,47 @@ module RubyLsp
           comments.to_h do |comment|
             [comment.location.end_line, comment]
           end,
-          T::Hash[Integer, YARP::Comment],
+          T::Hash[Integer, Prism::Comment],
         )
 
-        emitter.register(self, :on_def, :on_class, :on_module, :on_constant_write, :on_constant_path_write)
+        dispatcher.register(
+          self,
+          :on_def_node_enter,
+          :on_class_node_enter,
+          :on_module_node_enter,
+          :on_constant_write_node_enter,
+          :on_constant_path_write_node_enter,
+        )
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         extract_document_link(node)
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
         extract_document_link(node)
       end
 
-      sig { params(node: YARP::ModuleNode).void }
-      def on_module(node)
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
         extract_document_link(node)
       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)
         extract_document_link(node)
       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)
         extract_document_link(node)
       end
 
       private
 
-      sig { params(node: YARP::Node).void }
+      sig { params(node: Prism::Node).void }
       def extract_document_link(node)
         comment = @lines_to_comments[node.location.start_line - 1]
         return unless comment