rubocop 1.81.7 → 1.92.1

data/lib/rubocop/lsp/disable_comment_edits.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Builds LSP text edits for rubocop:disable comments.
+    # @api private
+    class DisableCommentEdits
+      def initialize(offense:, document_encoding:, processed_source:)
+        @offense = offense
+        @document_encoding = document_encoding
+        @processed_source = processed_source
+      end
+
+      def edits
+        literal_range = multiline_literal_range
+        return block_disable_comments(literal_range) if literal_range
+
+        inline_disable_comment
+      end
+
+      private
+
+      def inline_disable_comment
+        eol = position(@offense.line - 1, @offense.source_line.length, @offense.source_line)
+        [text_edit(eol, inline_comment_text)]
+      end
+
+      def inline_comment_text
+        if @offense.source_line.include?(' # rubocop:disable ')
+          ",#{@offense.cop_name}"
+        else
+          " # rubocop:disable #{@offense.cop_name}"
+        end
+      end
+
+      def block_disable_comments(range)
+        full_line_range = range_by_lines(range)
+        leading_whitespace = full_line_range.source_line[/^\s*/].to_s
+        [
+          disable_edit(full_line_range.first_line, leading_whitespace),
+          enable_edit(full_line_range, leading_whitespace)
+        ]
+      end
+
+      def disable_edit(first_line, leading_whitespace)
+        position = position(first_line - 1, 0, '')
+        text_edit(position, "#{leading_whitespace}# rubocop:disable #{@offense.cop_name}\n")
+      end
+
+      def enable_edit(full_line_range, leading_whitespace)
+        last_line = full_line_range.last_line
+        last_line_text = full_line_range.source_buffer.source_line(last_line)
+        position = position(last_line - 1, last_line_text.length, last_line_text)
+        text_edit(position, "\n#{leading_whitespace}# rubocop:enable #{@offense.cop_name}")
+      end
+
+      def text_edit(position, new_text)
+        range = LanguageServer::Protocol::Interface::Range.new(start: position, end: position)
+        LanguageServer::Protocol::Interface::TextEdit.new(range: range, new_text: new_text)
+      end
+
+      def position(line, utf8_index, line_text)
+        LanguageServer::Protocol::Interface::Position.new(
+          line: line,
+          character: position_character(utf8_index, line_text)
+        )
+      end
+
+      def position_character(utf8_index, line_text)
+        str = line_text[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.length
+        end
+      end
+
+      def multiline_literal_range
+        return unless @processed_source&.ast
+
+        offense_range = @offense.location
+        multiline_ranges&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+      end
+
+      def multiline_ranges
+        @processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
+
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      end
+
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/routes.rb

@@ -15,17 +15,15 @@ module RuboCop
   module LSP
     # Routes for Language Server Protocol of RuboCop.
     # @api private
-    class Routes # rubocop:disable Metrics/ClassLength
+    class Routes
       CONFIGURATION_FILE_PATTERNS = [
         RuboCop::ConfigFinder::DOTFILE,
         RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
       ].freeze
 
-      def self.handle(name, &block)
-        define_method(:"handle_#{name}", &block)
-      end
-
-      private_class_method :handle
+      # Commands handled by `workspace/executeCommand`. Advertised to the client
+      # via `executeCommandProvider` so it knows which commands it can invoke.
+      EXECUTE_COMMANDS = %w[rubocop.formatAutocorrects rubocop.formatAutocorrectsAll].freeze
 
       def initialize(server)
         @server = server
@@ -40,9 +38,31 @@ module RuboCop
         method(name)
       end
 
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      def self.handle(name, &block)
+        define_method(:"handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
       handle 'initialize' do |request|
         initialization_options = extract_initialization_options_from(request)
-        @position_encoding = initialization_options[:position_encoding]
 
         @server.configure(initialization_options)
 
@@ -51,11 +71,16 @@ module RuboCop
           result: LanguageServer::Protocol::Interface::InitializeResult.new(
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               document_formatting_provider: true,
+              code_action_provider: LanguageServer::Protocol::Interface::CodeActionOptions.new(
+                code_action_kinds: [LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX]
+              ),
+              execute_command_provider: LanguageServer::Protocol::Interface::ExecuteCommandOptions.new(
+                commands: EXECUTE_COMMANDS
+              ),
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
                 open_close: true
-              ),
-              position_encoding: @position_encoding
+              )
             )
           )
         )
@@ -63,9 +88,16 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
-        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
-
-        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
+        # Only one JIT can be enabled at the same time, since YJIT and ZJIT are mutually exclusive.
+        jit = if Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled?
+                '+YJIT'
+              elsif Object.const_defined?('RubyVM::ZJIT') && RubyVM::ZJIT.enabled?
+                '+ZJIT'
+              else
+                ''
+              end
+
+        Logger.log("RuboCop #{version} language server#{jit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|
@@ -102,18 +134,26 @@ module RuboCop
         @server.write(id: request[:id], result: format_file(uri))
       end
 
+      handle 'textDocument/codeAction' do |request|
+        @server.write(id: request[:id], result: code_actions_for(request[:params]))
+      end
+
       handle 'workspace/didChangeConfiguration' do |_request|
         Logger.log('Ignoring workspace/didChangeConfiguration')
       end
 
       handle 'workspace/didChangeWatchedFiles' do |request|
-        changed = request[:params][:changes].any? do |change|
+        config_changed = request[:params][:changes].any? do |change|
           CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
         end
 
-        if changed
+        if config_changed
           Logger.log('Configuration file changed; restart required')
           @server.stop
+        else
+          # A watched source file changed on disk, so the project index may be
+          # stale; drop it so the next diagnostics run rebuilds it.
+          @server.reset_project_index
         end
       end
 
@@ -128,25 +168,13 @@ module RuboCop
           return
         end
 
-        uri = request[:params][:arguments][0][:uri]
-        formatted = nil
-
-        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
-        # so the user's intention for autocorrection is respected.
-        LSP.disable { formatted = format_file(uri, command: command) }
-
-        @server.write(
-          id: request[:id],
-          method: 'workspace/applyEdit',
-          params: {
-            label: label,
-            edit: {
-              changes: {
-                uri => formatted
-              }
-            }
-          }
-        )
+        # Clients such as Eglot can invoke a command without arguments, so respond with
+        # an error instead of letting the server crash on a missing URI.
+        if (uri = document_uri_from(request))
+          write_formatting_edits(request, uri: uri, command: command, label: label)
+        else
+          write_invalid_arguments_error(request, command)
+        end
       end
 
       handle 'textDocument/willSave' do |_request|
@@ -154,7 +182,9 @@ module RuboCop
       end
 
       handle 'textDocument/didSave' do |_request|
-        # Nothing to do
+        # The buffer's contents are now on disk, so the project index may be
+        # stale; drop it so the next diagnostics run rebuilds it.
+        @server.reset_project_index
       end
 
       handle '$/cancelRequest' do |_request|
@@ -165,45 +195,57 @@ module RuboCop
         # No-op, we log everything
       end
 
-      def handle_unsupported_method(request, method = request[:method])
-        @server.write(
-          id: request[:id],
-          error: LanguageServer::Protocol::Interface::ResponseError.new(
-            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
-            message: "Unsupported Method: #{method}"
-          )
-        )
-        Logger.log("Unsupported Method: #{method}")
-      end
-
-      def handle_method_missing(request)
-        return unless request.key?(:id)
-
-        @server.write(id: request[:id], result: nil)
-      end
-
       private
 
       def extract_initialization_options_from(request)
         safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
-        position_encodings = request.dig(:params, :capabilities, :general, :positionEncodings)
 
         {
           safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
           lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
-          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true,
-          position_encoding: position_encoding(position_encodings)
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
         }
       end
 
-      def position_encoding(position_encodings)
-        if position_encodings&.include?('utf-8')
-          'utf-8'
-        elsif position_encodings&.include?('utf-32')
-          'utf-32'
-        else
-          'utf-16'
-        end
+      def document_uri_from(request)
+        argument = request.dig(:params, :arguments, 0)
+
+        argument[:uri] if argument.is_a?(Hash)
+      end
+
+      def write_formatting_edits(request, uri:, command:, label:)
+        formatted = nil
+
+        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
+        # so the user's intention for autocorrection is respected.
+        LSP.disable { formatted = format_file(uri, command: command) }
+
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => formatted
+              }
+            }
+          }
+        )
+      end
+
+      def write_invalid_arguments_error(request, command)
+        message = "Missing document URI in arguments for #{command}"
+
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INVALID_PARAMS,
+            message: message
+          )
+        )
+
+        Logger.log(message)
       end
 
       def format_file(file_uri, command: nil)
@@ -217,13 +259,31 @@ module RuboCop
 
         return [] if new_text == text
 
-        [
+        [{
           newText: new_text,
           range: {
             start: { line: 0, character: 0 },
             end: { line: text.count("\n") + 1, character: 0 }
           }
-        ]
+        }]
+      end
+
+      # Returns the quickfix code actions for a `textDocument/codeAction` request.
+      #
+      # RuboCop attaches each offense's autocorrect and disable-line actions to
+      # the diagnostic it publishes, under the diagnostic's `data` (see
+      # `Diagnostic#to_lsp_diagnostic`).  The LSP spec preserves that `data`
+      # between `textDocument/publishDiagnostics` and `textDocument/codeAction`,
+      # so the client hands the diagnostics back in the request's context and we
+      # can surface their actions without re-analyzing the file.  This makes the
+      # actions available to clients that request code actions rather than
+      # reading them off the diagnostic (Eglot, Helix, Flycheck, ...).
+      def code_actions_for(params)
+        diagnostics = params.dig(:context, :diagnostics) || []
+        only = params.dig(:context, :only)
+
+        diagnostics.flat_map { |diagnostic| diagnostic.dig(:data, :code_actions) || [] }
+                   .select { |action| only.nil? || only.include?(action[:kind]) }
       end
 
       def diagnostic(file_uri, text)
@@ -233,8 +293,7 @@ module RuboCop
           method: 'textDocument/publishDiagnostics',
           params: {
             uri: file_uri,
-            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri),
-                                          text, @position_encoding)
+            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri), text)
           }
         }
       end
@@ -244,8 +303,9 @@ module RuboCop
 
         start_pos = text_pos(orig_text, range[:start])
         end_pos = text_pos(orig_text, range[:end])
-        orig_text[start_pos...end_pos] = text
-        orig_text
+        text_bin = orig_text.b
+        text_bin[start_pos...end_pos] = text.b
+        text_bin.force_encoding(orig_text.encoding)
       end
 
       def text_pos(text, range)
@@ -254,27 +314,14 @@ module RuboCop
         pos = 0
         text.each_line.with_index do |l, i|
           if i == line
-            pos += line_pos(l, char)
+            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
             return pos
           end
-          pos += l.size
+          pos += l.bytesize
         end
         pos
       end
 
-      def line_pos(line, char)
-        case @position_encoding
-        when 'utf-8'
-          line.byteslice(0, char).size
-        when 'utf-32'
-          char
-        else # 'utf-16'
-          # utf-16 is default position encoding on LSP
-          # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/
-          line.encode('utf-16be').byteslice(0, char * 2).size
-        end
-      end
-
       def convert_file_uri_to_path(uri)
         URI.decode_www_form_component(uri.delete_prefix('file://'))
       end

data/lib/rubocop/lsp/runtime.rb

@@ -17,47 +17,96 @@ module RuboCop
     # Runtime for Language Server Protocol of RuboCop.
     # @api private
     class Runtime
-      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode, :raise_cop_error
 
-      def initialize(config_store)
-        RuboCop::LSP.enable
+      # Without `lsp_mode`, offenses keep the locations and messages the
+      # command line gives them, rather than the ones meant for an editor.
+      def initialize(config_store, lsp_mode: true)
+        RuboCop::LSP.enable if lsp_mode
 
         @runner = RuboCop::Lsp::StdinRunner.new(config_store)
-        @cop_registry = RuboCop::Cop::Registry.global.to_h
 
         @safe_autocorrect = true
         @lint_mode = false
         @layout_mode = false
+        @raise_cop_error = true
       end
 
-      def format(path, text, command:, prism_result: nil)
+      def format(path, text, command:, prism_result: nil, options: {})
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
                            else
                              @safe_autocorrect
                            end
 
-        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
-        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
+        formatting_options = {
+          autocorrect: true, safe_autocorrect: safe_autocorrect, raise_cop_error: @raise_cop_error
+        }.merge(call_options(options))
 
         @runner.run(path, text, formatting_options, prism_result: prism_result)
         @runner.formatted_source
       end
 
-      def offenses(path, text, position_encoding, prism_result: nil)
-        diagnostic_options = {}
-        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
+      def reset_project_index
+        @runner.reset_project_index
+      end
 
-        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
-        @runner.offenses.map do |offense|
-          Diagnostic.new(
-            position_encoding, offense, path, @cop_registry[offense.cop_name]&.first
-          ).to_lsp_diagnostic(@runner.config_for_working_directory)
+      def offenses(path, text, document_encoding = nil, prism_result: nil)
+        found = raw_offenses(path, text, prism_result: prism_result)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
+        found.map do |offense|
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
         end
       end
 
+      # The offenses before they are converted to LSP diagnostics, for callers
+      # that do not speak LSP.
+      def raw_offenses(path, text, prism_result: nil, options: {})
+        diagnostic_options = { raise_cop_error: @raise_cop_error }.merge(call_options(options))
+
+        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        @runner.offenses
+      end
+
+      # The offenses the last `format` found but didn't correct, located in the
+      # source it returned.
+      def uncorrected_offenses
+        @runner.offenses.reject(&:corrected?)
+      end
+
+      # What went wrong in the last run. Cop errors only end up here when
+      # `raise_cop_error` is off; otherwise they are raised.
+      def errors
+        @runner.errors
+      end
+
+      def warnings
+        @runner.warnings
+      end
+
       private
 
+      def build_diagnostic(offense, path, document_encoding, processed_source, config)
+        Diagnostic.new(
+          document_encoding,
+          offense,
+          path,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
+          processed_source
+        ).to_lsp_diagnostic(config)
+      end
+
+      # What a caller adds for one call, such as `only` and `except` to select
+      # the cops, or `editing` to hold back the corrections of cops with
+      # `AutoCorrect: contextual`, as LSP mode does. Without `only`, the cops
+      # are the departments a lint or layout mode limits the server to.
+      def call_options(options)
+        return options if options[:only] || !(@lint_mode || @layout_mode)
+
+        options.merge(only: config_only_options)
+      end
+
       def config_only_options
         only_options = []
         only_options << 'Lint' if @lint_mode

data/lib/rubocop/lsp/server.rb

@@ -51,8 +51,8 @@ module RuboCop
         @runtime.format(path, text, command: command)
       end
 
-      def offenses(path, text, position_encoding)
-        @runtime.offenses(path, text, position_encoding)
+      def offenses(path, text)
+        @runtime.offenses(path, text)
       end
 
       def configure(options)
@@ -61,6 +61,10 @@ module RuboCop
         @runtime.layout_mode = options[:layout_mode]
       end
 
+      def reset_project_index
+        @runtime.reset_project_index
+      end
+
       def stop(&block)
         at_exit(&block) if block
         exit

data/lib/rubocop/lsp/stdin_runner.rb

@@ -17,13 +17,12 @@ module RuboCop
     class StdinRunner < RuboCop::Runner
       class ConfigurationError < StandardError; end
 
-      attr_reader :offenses, :config_for_working_directory
+      attr_reader :offenses, :config_for_working_directory, :processed_source
 
       DEFAULT_RUBOCOP_OPTIONS = {
         stderr: true,
         force_exclusion: true,
         formatters: ['RuboCop::Formatter::BaseFormatter'],
-        raise_cop_error: true,
         todo_file: nil,
         todo_ignore_files: []
       }.freeze
@@ -41,10 +40,18 @@ module RuboCop
       end
 
       def run(path, contents, options, prism_result: nil)
+        # The cops mobilized for a configuration are cached, which only holds while
+        # every run asks for the same ones.
+        selection = options.values_at(:only, :except)
+        unless selection == @cop_selection
+          forget_mobilized_cops
+          @cop_selection = selection
+        end
         @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
         @options[:stdin] = contents
 
         @prism_result = prism_result
+        @processed_source = nil
 
         @offenses = []
         @warnings = []
@@ -59,11 +66,37 @@ module RuboCop
         @options[:stdin]
       end
 
+      # Drop the cached project index so the next run rebuilds it. Called when a
+      # file is saved or a watched file changes, i.e. when the on-disk state the
+      # index is derived from may have changed.
+      def reset_project_index
+        @project_index = nil
+        @project_index_built = false
+      end
+
       private
 
+      # The project index is built from files on disk, not from the in-memory
+      # buffer, so it does not change while the user is typing. Build it once and
+      # reuse it across runs instead of re-walking and re-indexing the whole
+      # project on every request; `reset_project_index` drops the cache when the
+      # on-disk state changes.
+      def build_project_index(target_files)
+        return if @project_index_built
+
+        super
+        @project_index_built = true
+      end
+
       def file_finished(_file, offenses)
         @offenses = offenses
       end
+
+      def do_inspection_loop(file, source = nil)
+        processed_source, offenses = super
+        @processed_source = processed_source
+        [processed_source, offenses]
+      end
     end
   end
 end

data/lib/rubocop/lsp.rb

@@ -26,8 +26,11 @@ module RuboCop
       if block
         original = @enabled
         @enabled = false
-        yield
-        @enabled = original
+        begin
+          yield
+        ensure
+          @enabled = original
+        end
       else
         @enabled = false
       end