ruby-lsp 0.11.2 → 0.12.1

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -20,123 +20,31 @@ module RubyLsp
     #   puts "Hello, world!" # --> Cursor is on this line
     # end
     # ```
-    class SelectionRanges < BaseRequest
+    class SelectionRanges
       extend T::Sig
-
-      NODES_THAT_CAN_BE_PARENTS = T.let(
-        [
-          YARP::ArgumentsNode,
-          YARP::ArrayNode,
-          YARP::AssocNode,
-          YARP::BeginNode,
-          YARP::BlockNode,
-          YARP::CallNode,
-          YARP::CaseNode,
-          YARP::ClassNode,
-          YARP::DefNode,
-          YARP::ElseNode,
-          YARP::EnsureNode,
-          YARP::ForNode,
-          YARP::HashNode,
-          YARP::HashPatternNode,
-          YARP::IfNode,
-          YARP::InNode,
-          YARP::InterpolatedStringNode,
-          YARP::KeywordHashNode,
-          YARP::LambdaNode,
-          YARP::LocalVariableWriteNode,
-          YARP::ModuleNode,
-          YARP::ParametersNode,
-          YARP::RescueNode,
-          YARP::StringConcatNode,
-          YARP::StringNode,
-          YARP::UnlessNode,
-          YARP::UntilNode,
-          YARP::WhenNode,
-          YARP::WhileNode,
-        ].freeze,
-        T::Array[T.class_of(YARP::Node)],
-      )
-
+      include Support::Common
       sig { params(document: Document).void }
       def initialize(document)
-        super(document)
-
+        @document = document
         @ranges = T.let([], T::Array[Support::SelectionRange])
         @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
-      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
+      sig { returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
-        visit(@document.tree)
-        @ranges.reverse!
-      end
+        # [node, parent]
+        queue = [[@document.tree, nil]]
 
-      private
+        until queue.empty?
+          node, parent = queue.shift
+          next unless node
 
-      sig { override.params(node: T.nilable(YARP::Node)).void }
-      def visit(node)
-        return if node.nil?
-
-        range = if node.is_a?(YARP::InterpolatedStringNode)
-          create_heredoc_selection_range(node, @stack.last)
-        else
-          create_selection_range(node.location, @stack.last)
+          range = Support::SelectionRange.new(range: range_from_location(node.location), parent: parent)
+          T.unsafe(queue).unshift(*node.child_nodes.map { |child| [child, range] })
+          @ranges.unshift(range)
         end
-        @ranges << range
-
-        return if node.child_nodes.empty?
 
-        @stack << range if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
-        visit_all(node.child_nodes)
-        @stack.pop if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
-      end
-
-      sig do
-        params(
-          node: YARP::InterpolatedStringNode,
-          parent: T.nilable(Support::SelectionRange),
-        ).returns(Support::SelectionRange)
-      end
-      def create_heredoc_selection_range(node, parent)
-        opening_loc = node.opening_loc || node.location
-        closing_loc = node.closing_loc || node.location
-
-        RubyLsp::Requests::Support::SelectionRange.new(
-          range: Interface::Range.new(
-            start: Interface::Position.new(
-              line: opening_loc.start_line - 1,
-              character: opening_loc.start_column,
-            ),
-            end: Interface::Position.new(
-              line: closing_loc.end_line - 1,
-              character: closing_loc.end_column,
-            ),
-          ),
-          parent: parent,
-        )
-      end
-
-      sig do
-        params(
-          location: YARP::Location,
-          parent: T.nilable(Support::SelectionRange),
-        ).returns(Support::SelectionRange)
-      end
-      def create_selection_range(location, parent)
-        RubyLsp::Requests::Support::SelectionRange.new(
-          range: Interface::Range.new(
-            start: Interface::Position.new(
-              line: location.start_line - 1,
-              character: location.start_column,
-            ),
-            end: Interface::Position.new(
-              line: location.end_line - 1,
-              character: location.end_column,
-            ),
-          ),
-          parent: parent,
-        )
+        @ranges
       end
     end
   end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -83,7 +83,7 @@ module RubyLsp
       class SemanticToken
         extend T::Sig
 
-        sig { returns(YARP::Location) }
+        sig { returns(Prism::Location) }
         attr_reader :location
 
         sig { returns(Integer) }
@@ -95,7 +95,7 @@ module RubyLsp
         sig { returns(T::Array[Integer]) }
         attr_reader :modifier
 
-        sig { params(location: YARP::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
+        sig { params(location: Prism::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
         def initialize(location:, length:, type:, modifier:)
           @location = location
           @length = length
@@ -109,53 +109,53 @@ module RubyLsp
 
       sig do
         params(
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
           range: T.nilable(T::Range[Integer]),
         ).void
       end
-      def initialize(emitter, message_queue, range: nil)
-        super(emitter, message_queue)
+      def initialize(dispatcher, message_queue, range: nil)
+        super(dispatcher, message_queue)
 
         @_response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
         @current_scope = T.let(ParameterScope.new, ParameterScope)
 
-        emitter.register(
+        dispatcher.register(
           self,
-          :on_call,
-          :on_class,
-          :on_def,
-          :after_def,
-          :on_block,
-          :after_block,
-          :on_self,
-          :on_module,
-          :on_local_variable_write,
-          :on_local_variable_read,
-          :on_block_parameter,
-          :on_keyword_parameter,
-          :on_keyword_rest_parameter,
-          :on_optional_parameter,
-          :on_required_parameter,
-          :on_rest_parameter,
-          :on_constant_read,
-          :on_constant_write,
-          :on_constant_and_write,
-          :on_constant_operator_write,
-          :on_constant_or_write,
-          :on_constant_target,
-          :on_local_variable_and_write,
-          :on_local_variable_operator_write,
-          :on_local_variable_or_write,
-          :on_local_variable_target,
-          :on_block_local_variable,
+          :on_call_node_enter,
+          :on_class_node_enter,
+          :on_def_node_enter,
+          :on_def_node_leave,
+          :on_block_node_enter,
+          :on_block_node_leave,
+          :on_self_node_enter,
+          :on_module_node_enter,
+          :on_local_variable_write_node_enter,
+          :on_local_variable_read_node_enter,
+          :on_block_parameter_node_enter,
+          :on_keyword_parameter_node_enter,
+          :on_keyword_rest_parameter_node_enter,
+          :on_optional_parameter_node_enter,
+          :on_required_parameter_node_enter,
+          :on_rest_parameter_node_enter,
+          :on_constant_read_node_enter,
+          :on_constant_write_node_enter,
+          :on_constant_and_write_node_enter,
+          :on_constant_operator_write_node_enter,
+          :on_constant_or_write_node_enter,
+          :on_constant_target_node_enter,
+          :on_local_variable_and_write_node_enter,
+          :on_local_variable_operator_write_node_enter,
+          :on_local_variable_or_write_node_enter,
+          :on_local_variable_target_node_enter,
+          :on_block_local_variable_node_enter,
         )
       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 visible?(node, @range)
 
         message = node.message
@@ -172,8 +172,8 @@ module RubyLsp
         add_token(T.must(node.message_loc), type)
       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 unless visible?(node, @range)
         # When finding a module or class definition, we will have already pushed a token related to this constant. We
         # need to look at the previous two tokens and if they match this locatione exactly, avoid pushing another token
@@ -183,77 +183,77 @@ module RubyLsp
         add_token(node.location, :namespace)
       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 unless visible?(node, @range)
 
         add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: YARP::ConstantAndWriteNode).void }
-      def on_constant_and_write(node)
+      sig { params(node: Prism::ConstantAndWriteNode).void }
+      def on_constant_and_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: YARP::ConstantOperatorWriteNode).void }
-      def on_constant_operator_write(node)
+      sig { params(node: Prism::ConstantOperatorWriteNode).void }
+      def on_constant_operator_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: YARP::ConstantOrWriteNode).void }
-      def on_constant_or_write(node)
+      sig { params(node: Prism::ConstantOrWriteNode).void }
+      def on_constant_or_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: YARP::ConstantTargetNode).void }
-      def on_constant_target(node)
+      sig { params(node: Prism::ConstantTargetNode).void }
+      def on_constant_target_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.location, :namespace)
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         @current_scope = ParameterScope.new(@current_scope)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, :method, [:declaration])
       end
 
-      sig { params(node: YARP::DefNode).void }
-      def after_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_leave(node)
         @current_scope = T.must(@current_scope.parent)
       end
 
-      sig { params(node: YARP::BlockNode).void }
-      def on_block(node)
+      sig { params(node: Prism::BlockNode).void }
+      def on_block_node_enter(node)
         @current_scope = ParameterScope.new(@current_scope)
       end
 
-      sig { params(node: YARP::BlockNode).void }
-      def after_block(node)
+      sig { params(node: Prism::BlockNode).void }
+      def on_block_node_leave(node)
         @current_scope = T.must(@current_scope.parent)
       end
 
-      sig { params(node: YARP::BlockLocalVariableNode).void }
-      def on_block_local_variable(node)
+      sig { params(node: Prism::BlockLocalVariableNode).void }
+      def on_block_local_variable_node_enter(node)
         add_token(node.location, :variable)
       end
 
-      sig { params(node: YARP::BlockParameterNode).void }
-      def on_block_parameter(node)
+      sig { params(node: Prism::BlockParameterNode).void }
+      def on_block_parameter_node_enter(node)
         name = node.name
         @current_scope << name.to_sym if name
       end
 
-      sig { params(node: YARP::KeywordParameterNode).void }
-      def on_keyword_parameter(node)
+      sig { params(node: Prism::KeywordParameterNode).void }
+      def on_keyword_parameter_node_enter(node)
         name = node.name
         @current_scope << name.to_s.delete_suffix(":").to_sym if name
 
@@ -263,8 +263,8 @@ module RubyLsp
         add_token(location.copy(length: location.length - 1), :parameter)
       end
 
-      sig { params(node: YARP::KeywordRestParameterNode).void }
-      def on_keyword_rest_parameter(node)
+      sig { params(node: Prism::KeywordRestParameterNode).void }
+      def on_keyword_rest_parameter_node_enter(node)
         name = node.name
 
         if name
@@ -274,24 +274,24 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::OptionalParameterNode).void }
-      def on_optional_parameter(node)
+      sig { params(node: Prism::OptionalParameterNode).void }
+      def on_optional_parameter_node_enter(node)
         @current_scope << node.name
         return unless visible?(node, @range)
 
         add_token(node.name_loc, :parameter)
       end
 
-      sig { params(node: YARP::RequiredParameterNode).void }
-      def on_required_parameter(node)
+      sig { params(node: Prism::RequiredParameterNode).void }
+      def on_required_parameter_node_enter(node)
         @current_scope << node.name
         return unless visible?(node, @range)
 
         add_token(node.location, :parameter)
       end
 
-      sig { params(node: YARP::RestParameterNode).void }
-      def on_rest_parameter(node)
+      sig { params(node: Prism::RestParameterNode).void }
+      def on_rest_parameter_node_enter(node)
         name = node.name
 
         if name
@@ -301,22 +301,22 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::SelfNode).void }
-      def on_self(node)
+      sig { params(node: Prism::SelfNode).void }
+      def on_self_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.location, :variable, [:default_library])
       end
 
-      sig { params(node: YARP::LocalVariableWriteNode).void }
-      def on_local_variable_write(node)
+      sig { params(node: Prism::LocalVariableWriteNode).void }
+      def on_local_variable_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::LocalVariableReadNode).void }
-      def on_local_variable_read(node)
+      sig { params(node: Prism::LocalVariableReadNode).void }
+      def on_local_variable_read_node_enter(node)
         return unless visible?(node, @range)
 
         # Numbered parameters
@@ -328,36 +328,36 @@ module RubyLsp
         add_token(node.location, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::LocalVariableAndWriteNode).void }
-      def on_local_variable_and_write(node)
+      sig { params(node: Prism::LocalVariableAndWriteNode).void }
+      def on_local_variable_and_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::LocalVariableOperatorWriteNode).void }
-      def on_local_variable_operator_write(node)
+      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      def on_local_variable_operator_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::LocalVariableOrWriteNode).void }
-      def on_local_variable_or_write(node)
+      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      def on_local_variable_or_write_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::LocalVariableTargetNode).void }
-      def on_local_variable_target(node)
+      sig { params(node: Prism::LocalVariableTargetNode).void }
+      def on_local_variable_target_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.location, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.constant_path.location, :class, [:declaration])
@@ -366,14 +366,16 @@ module RubyLsp
         add_token(superclass.location, :class) if superclass
       end
 
-      sig { params(node: YARP::ModuleNode).void }
-      def on_module(node)
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
         return unless visible?(node, @range)
 
         add_token(node.constant_path.location, :namespace, [:declaration])
       end
 
-      sig { params(location: YARP::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      private
+
+      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
         length = location.end_offset - location.start_offset
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
@@ -387,8 +389,6 @@ module RubyLsp
         )
       end
 
-      private
-
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that
       # highlighting, so we avoid making a semantic token for it.
       sig { params(method_name: String).returns(T::Boolean) }
@@ -396,12 +396,12 @@ module RubyLsp
         SPECIAL_RUBY_METHODS.include?(method_name)
       end
 
-      sig { params(node: YARP::CallNode).void }
+      sig { params(node: Prism::CallNode).void }
       def process_regexp_locals(node)
         receiver = node.receiver
 
         # The regexp needs to be the receiver of =~ for local variable capture
-        return unless receiver.is_a?(YARP::RegularExpressionNode)
+        return unless receiver.is_a?(Prism::RegularExpressionNode)
 
         content = receiver.content
         loc = receiver.content_loc

data/lib/ruby_lsp/requests/support/annotation.rb

@@ -17,20 +17,20 @@ module RubyLsp
           @receiver = receiver
         end
 
-        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        sig { params(node: Prism::CallNode).returns(T::Boolean) }
         def match?(node)
           receiver_matches?(node) && arity_matches?(node)
         end
 
         private
 
-        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        sig { params(node: Prism::CallNode).returns(T::Boolean) }
         def receiver_matches?(node)
           node_receiver = node.receiver
           (node_receiver && @receiver && node_receiver.location.slice == "T") || (!node_receiver && !@receiver)
         end
 
-        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        sig { params(node: Prism::CallNode).returns(T::Boolean) }
         def arity_matches?(node)
           node_arity = node.arguments&.arguments&.size || 0
 

data/lib/ruby_lsp/requests/support/common.rb

@@ -10,7 +10,7 @@ module RubyLsp
         # cautious of changing anything.
         extend T::Sig
 
-        sig { params(node: YARP::Node).returns(Interface::Range) }
+        sig { params(node: Prism::Node).returns(Interface::Range) }
         def range_from_node(node)
           loc = node.location
 
@@ -23,7 +23,7 @@ module RubyLsp
           )
         end
 
-        sig { params(location: YARP::Location).returns(Interface::Range) }
+        sig { params(location: Prism::Location).returns(Interface::Range) }
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -34,7 +34,7 @@ module RubyLsp
           )
         end
 
-        sig { params(node: T.nilable(YARP::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+        sig { params(node: T.nilable(Prism::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
         def visible?(node, range)
           return true if range.nil?
           return false if node.nil?
@@ -45,7 +45,7 @@ module RubyLsp
 
         sig do
           params(
-            node: YARP::Node,
+            node: Prism::Node,
             title: String,
             command_name: String,
             arguments: T.nilable(T::Array[T.untyped]),
@@ -66,7 +66,7 @@ module RubyLsp
           )
         end
 
-        sig { params(title: String, entries: T::Array[RubyIndexer::Index::Entry]).returns(Interface::MarkupContent) }
+        sig { params(title: String, entries: T::Array[RubyIndexer::Entry]).returns(Interface::MarkupContent) }
         def markdown_from_index_entries(title, entries)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -9,9 +9,9 @@ module RubyLsp
 
         RUBOCOP_TO_LSP_SEVERITY = T.let(
           {
-            convention: Constant::DiagnosticSeverity::INFORMATION,
-            info: Constant::DiagnosticSeverity::INFORMATION,
+            info: Constant::DiagnosticSeverity::HINT,
             refactor: Constant::DiagnosticSeverity::INFORMATION,
+            convention: Constant::DiagnosticSeverity::INFORMATION,
             warning: Constant::DiagnosticSeverity::WARNING,
             error: Constant::DiagnosticSeverity::ERROR,
             fatal: Constant::DiagnosticSeverity::ERROR,
@@ -47,15 +47,11 @@ module RubyLsp
 
         sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
-          severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
-          message  = @offense.message
-
-          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
-
           Interface::Diagnostic.new(
             message: message,
             source: "RuboCop",
             code: @offense.cop_name,
+            code_description: code_description,
             severity: severity,
             range: Interface::Range.new(
               start: Interface::Position.new(
@@ -76,6 +72,24 @@ module RubyLsp
 
         private
 
+        sig { returns(String) }
+        def message
+          message  = @offense.message
+          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
+          message
+        end
+
+        sig { returns(T.nilable(Integer)) }
+        def severity
+          RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+        end
+
+        sig { returns(T.nilable(Interface::CodeDescription)) }
+        def code_description
+          doc_url = RuboCopRunner.find_cop_by_name(@offense.cop_name)&.documentation_url
+          Interface::CodeDescription.new(href: doc_url) if doc_url
+        end
+
         sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -101,6 +101,25 @@ module RubyLsp
           @options[:stdin]
         end
 
+        class << self
+          extend T::Sig
+
+          sig { params(cop_name: String).returns(T.nilable(T.class_of(RuboCop::Cop::Base))) }
+          def find_cop_by_name(cop_name)
+            cop_registry[cop_name]&.first
+          end
+
+          private
+
+          sig { returns(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]) }
+          def cop_registry
+            @cop_registry ||= T.let(
+              RuboCop::Cop::Registry.global.to_h,
+              T.nilable(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]),
+            )
+          end
+        end
+
         private
 
         sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }