ruby-lsp 0.11.1 → 0.12.0

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/dependency_detector.rb

@@ -56,7 +56,7 @@ module RubyLsp
 
     sig { params(gem_pattern: Regexp).returns(T::Boolean) }
     def direct_dependency?(gem_pattern)
-      dependency_keys.grep(gem_pattern).any?
+      dependencies.any?(gem_pattern)
     end
 
     sig { returns(T::Boolean) }
@@ -65,16 +65,24 @@ module RubyLsp
     end
 
     sig { returns(T::Array[String]) }
-    def dependency_keys
-      @dependency_keys ||= T.let(
+    def dependencies
+      # NOTE: If changing this behaviour, it's likely that the VS Code extension will also need changed.
+      @dependencies ||= T.let(
         begin
           Bundler.with_original_env { Bundler.default_gemfile }
-          Bundler.locked_gems.dependencies.keys
+          Bundler.locked_gems.dependencies.keys + gemspec_dependencies
         rescue Bundler::GemfileNotFound
           []
         end,
         T.nilable(T::Array[String]),
       )
     end
+
+    sig { returns(T::Array[String]) }
+    def gemspec_dependencies
+      Bundler.locked_gems.sources
+        .grep(Bundler::Source::Gemspec)
+        .flat_map { _1.gemspec&.dependencies&.map(&:name) }
+    end
   end
 end

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

@@ -19,6 +19,12 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
+        # Cache cops to attach URLs to diagnostics. Only built-in cops for now.
+        COP_TO_DOC_URL = T.let(
+          RuboCop::Cop::Registry.global.to_h,
+          T::Hash[String, [T.class_of(RuboCop::Cop::Base)]],
+        )
+
         sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(offense, uri)
           @offense = offense
@@ -47,18 +53,21 @@ module RubyLsp
 
         sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
-          if @offense.correctable?
-            severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
-            message = @offense.message
-          else
-            severity = Constant::DiagnosticSeverity::WARNING
-            message = "#{@offense.message}\n\nThis offense is not auto-correctable.\n"
+          severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+          message  = @offense.message
+
+          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
+
+          cop = COP_TO_DOC_URL[@offense.cop_name]&.first
+          if cop&.documentation_url
+            code_description = { href: cop.documentation_url }
           end
 
           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(