rubocop 1.45.1 → 1.50.1

data/lib/rubocop/cop/internal_affairs/example_heredoc_delimiter.rb

@@ -52,7 +52,7 @@ module RuboCop
         # @return [void]
         def autocorrect(corrector, node)
           [
-            heredoc_openning_delimiter_range_from(node),
+            heredoc_opening_delimiter_range_from(node),
             heredoc_closing_delimiter_range_from(node)
           ].each do |range|
             corrector.replace(range, EXPECTED_HEREDOC_DELIMITER)
@@ -90,9 +90,9 @@ module RuboCop
 
         # @param node [RuboCop::AST::StrNode]
         # @return [Parser::Source::Range]
-        def heredoc_openning_delimiter_range_from(node)
+        def heredoc_opening_delimiter_range_from(node)
           match_data = node.source.match(Heredoc::OPENING_DELIMITER)
-          node.location.expression.begin.adjust(
+          node.source_range.begin.adjust(
             begin_pos: match_data.begin(2),
             end_pos: match_data.end(2)
           )

data/lib/rubocop/cop/internal_affairs/inherit_deprecated_cop_class.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # `RuboCop::Cop::Cop` is deprecated and will be removed in Rubocop 2.0.
+      # `RuboCop::Cop::Cop` is deprecated and will be removed in RuboCop 2.0.
       # Your custom cop class should inherit from `RuboCop::Cop::Base` instead of
       # `RuboCop::Cop::Cop`.
       #

data/lib/rubocop/cop/internal_affairs/location_expression.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.source_range` instead of `node.location.expression`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.location.expression
+      #   node.loc.expression
+      #
+      #   # good
+      #   node.source_range
+      #
+      class LocationExpression < Base
+        extend AutoCorrector
+
+        MSG = 'Use `source_range` instead.'
+        RESTRICT_ON_SEND = %i[loc location].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent)
+          return unless parent.send_type? && parent.method?(:expression)
+          return unless parent.receiver.receiver
+
+          offense = node.loc.selector.join(parent.source_range.end)
+
+          add_offense(offense) do |corrector|
+            corrector.replace(offense, 'source_range')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -99,7 +99,7 @@ module RuboCop
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
-          range = range_with_surrounding_space(node.loc.expression, side: :left, newlines: false)
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
           indentation = range.source.match(/^\s*/)[0]
           directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
           directive = "\n#{directive}" if add_newline?(node)

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -30,7 +30,7 @@ module RuboCop
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
+              range = node.source_range.with(begin_pos: receiver.source_range.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

data/lib/rubocop/cop/internal_affairs/processed_source_buffer_name.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `processed_source.file_path` instead of `processed_source.buffer.name`.
+      #
+      # @example
+      #
+      #   # bad
+      #   processed_source.buffer.name
+      #
+      #   # good
+      #   processed_source.file_path
+      #
+      class ProcessedSourceBufferName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `file_path` instead.'
+
+        RESTRICT_ON_SEND = %i[name].freeze
+
+        # @!method processed_source_buffer_name?(node)
+        def_node_matcher :processed_source_buffer_name?, <<~PATTERN
+          (send
+            (send
+              {(lvar :processed_source) (send nil? :processed_source)} :buffer) :name)
+        PATTERN
+
+        def on_send(node)
+          return unless processed_source_buffer_name?(node)
+
+          offense_range = node.children.first.loc.selector.begin.join(node.source_range.end)
+
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'file_path')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/redundant_source_range.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `source_range`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.source_range.source
+      #
+      #   # good
+      #   node.source
+      #
+      #   # bad
+      #   add_offense(node) { |corrector| corrector.replace(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before_multi(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node.source_range, before, after) }
+      #
+      #   # good
+      #   add_offense(node) { |corrector| corrector.replace(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node, before, after) }
+      #
+      class RedundantSourceRange < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `source_range`.'
+        RESTRICT_ON_SEND = %i[
+          source
+          replace remove insert_before insert_before_multi insert_after insert_after_multi swap
+        ].freeze
+
+        # @!method redundant_source_range(node)
+        def_node_matcher :redundant_source_range, <<~PATTERN
+          {
+            (send $(send _ :source_range) :source)
+            (send _ {
+              :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
+            } $(send _ :source_range) _)
+            (send _ :remove $(send _ :source_range))
+            (send _ :swap $(send _ :source_range) _ _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (source_range = redundant_source_range(node))
+          return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
+
+          selector = source_range.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(source_range.loc.dot.join(selector))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -7,6 +7,7 @@ require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
 require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'
@@ -15,12 +16,14 @@ require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
 require_relative 'internal_affairs/redundant_method_dispatch_node'
+require_relative 'internal_affairs/redundant_source_range'
 require_relative 'internal_affairs/single_line_comparison'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -36,17 +36,19 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          register_offense(node)
+          offense_range = offense_range(node)
+          return if offense_range.source.lstrip.start_with?(';')
+
+          register_offense(node, offense_range)
         end
 
         alias on_numblock on_block
 
         private
 
-        def register_offense(node)
+        def register_offense(node, offense_range)
           add_offense(node.loc.end, message: message(node)) do |corrector|
-            offense_range = offense_range(node)
-            replacement = replacement(node)
+            replacement = "\n#{offense_range.source.lstrip}"
 
             if (heredoc = last_heredoc_argument(node.body))
               corrector.remove(offense_range)
@@ -72,23 +74,7 @@ module RuboCop
         end
 
         def offense_range(node)
-          Parser::Source::Range.new(
-            node.loc.expression.source_buffer,
-            node.children.compact.last.loc.expression.end_pos,
-            end_of_method_chain(node).loc.expression.end_pos
-          )
-        end
-
-        def replacement(node)
-          end_with_method_chain = node.loc.end.join(end_of_method_chain(node).loc.expression.end)
-
-          "\n#{end_with_method_chain.source.strip}"
-        end
-
-        def end_of_method_chain(node)
-          return node unless node.parent&.call_type?
-
-          end_of_method_chain(node.parent)
+          node.children.compact.last.source_range.end.join(node.loc.end)
         end
       end
     end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -159,6 +159,7 @@ module RuboCop
             previous = index
           end
         end
+        alias on_sclass on_class
 
         private
 
@@ -285,10 +286,12 @@ module RuboCop
         end
 
         def end_position_for(node)
-          heredoc = find_heredoc(node)
-          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          if node.casgn_type?
+            heredoc = find_heredoc(node)
+            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          end
 
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 

data/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def heredoc_opening(node)
-          node.loc.expression.source_line
+          node.source_range.source_line
         end
 
         def heredoc_closing(node)

data/lib/rubocop/cop/layout/empty_comment.rb

@@ -97,9 +97,9 @@ module RuboCop
         def autocorrect(corrector, node)
           previous_token = previous_token(node)
           range = if previous_token && same_line?(node, previous_token)
-                    range_with_surrounding_space(node.loc.expression, newlines: false)
+                    range_with_surrounding_space(node.source_range, newlines: false)
                   else
-                    range_by_whole_lines(node.loc.expression, include_final_newline: true)
+                    range_by_whole_lines(node.source_range, include_final_newline: true)
                   end
 
           corrector.remove(range)
@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def current_token(comment)
-          processed_source.find_token { |token| token.pos == comment.loc.expression }
+          processed_source.tokens.find { |token| token.pos == comment.source_range }
         end
 
         def previous_token(node)

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -235,7 +235,7 @@ module RuboCop
 
         def end_loc(node)
           if (node.def_type? || node.defs_type?) && node.endless?
-            node.loc.expression.end
+            node.source_range.end
           else
             node.loc.end
           end

data/lib/rubocop/cop/layout/empty_lines.rb

@@ -31,7 +31,7 @@ module RuboCop
           return unless processed_source.raw_source.include?("\n\n\n")
 
           lines = Set.new
-          processed_source.each_token { |token| lines << token.line }
+          processed_source.tokens.each { |token| lines << token.line }
 
           each_extra_empty_line(lines.sort) do |range|
             add_offense(range) do |corrector|

data/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb

@@ -51,6 +51,8 @@ module RuboCop
         MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
         MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
 
+        RESTRICT_ON_SEND = %i[public protected private module_function].freeze
+
         def initialize(config = nil, options = nil)
           super
 

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -82,6 +82,10 @@ module RuboCop
           check_other_alignment(node)
         end
 
+        def on_sclass(node)
+          check_other_alignment(node)
+        end
+
         def on_module(node)
           check_other_alignment(node)
         end
@@ -105,6 +109,7 @@ module RuboCop
             check_other_alignment(node)
           end
         end
+        alias on_case_match on_case
 
         private
 
@@ -165,7 +170,10 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
+          if (node.case_type? || node.case_match_type?) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
 
           assignment = assignment_or_operator_method(node)
 

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def aligned_locations(locs)
+        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
           return [] if locs.empty?
 
           aligned = Set[locs.first.line, locs.last.line]
@@ -57,6 +57,11 @@ module RuboCop
             col = loc.column
             aligned << loc.line if col == before.column || col == after.column
           end
+
+          # if locs.size > 2 and the size of variable `aligned`
+          # has not increased from its initial value, there are not aligned lines.
+          return [] if locs.size > 2 && aligned.size == 2
+
           aligned
         end
 

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -153,9 +153,10 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
+          return unless should_check?(node)
+          return if same_line?(node, node.first_argument)
           return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
-          return if !node.arguments? || bare_operator?(node) || node.setter_method?
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -166,6 +167,10 @@ module RuboCop
 
         private
 
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
@@ -255,7 +260,7 @@ module RuboCop
           @comment_lines ||=
             processed_source
             .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
+            .select { |c| begins_its_line?(c.source_range) }
             .map { |c| c.loc.line }
         end
 

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -67,8 +67,7 @@ module RuboCop
 
           outermost_send = outermost_send_on_same_line(heredoc_arg)
           return unless outermost_send
-          return unless outermost_send.loc.end
-          return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if end_keyword_before_closing_parenthesis?(node)
           return if subsequent_closing_parentheses_in_same_line?(outermost_send)
           return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
@@ -160,6 +159,12 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def end_keyword_before_closing_parenthesis?(parenthesized_send_node)
+          parenthesized_send_node.ancestors.any? do |ancestor|
+            ancestor.loc.respond_to?(:end) && ancestor.loc.end&.source == 'end'
+          end
+        end
+
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
           return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
@@ -215,6 +220,7 @@ module RuboCop
         end
 
         def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return true unless node.loc.end
           return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
 
           heredoc_end < node.loc.end.begin_pos &&

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -115,7 +115,7 @@ module RuboCop
         end
 
         def adjust_minus(corrector, node)
-          heredoc_beginning = node.loc.expression.source
+          heredoc_beginning = node.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
           corrector.replace(node, corrected)
         end
@@ -139,7 +139,7 @@ module RuboCop
         end
 
         def base_indent_level(node)
-          base_line_num = node.loc.expression.line
+          base_line_num = node.source_range.line
           base_line = processed_source.lines[base_line_num - 1]
           indent_level(base_line)
         end

data/lib/rubocop/cop/layout/initial_indentation.rb

@@ -34,7 +34,7 @@ module RuboCop
         private
 
         def first_token
-          processed_source.find_token { |t| !t.text.start_with?('#') }
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
         end
 
         def space_before(token)

data/lib/rubocop/cop/layout/leading_comment_space.rb

@@ -63,7 +63,7 @@ module RuboCop
             next if gemfile_ruby_comment?(comment)
 
             add_offense(comment) do |corrector|
-              expr = comment.loc.expression
+              expr = comment.source_range
 
               corrector.insert_after(hash_mark(expr), ' ')
             end

data/lib/rubocop/cop/layout/line_continuation_leading_space.rb

@@ -51,12 +51,11 @@ module RuboCop
         private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
                          :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
-        # rubocop:disable Metrics/AbcSize
         def on_dstr(node)
           # Quick check if we possibly have line continuations.
           return unless node.source.include?('\\')
 
-          end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
+          end_of_first_line = node.source_range.begin_pos - node.source_range.column
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
             end_of_first_line += raw_line_one.length
@@ -70,7 +69,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/layout/line_continuation_spacing.rb

@@ -87,22 +87,26 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        def string_literal_ranges(ast)
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ranges = Set.new
-          ast.each_node(:str, :dstr) do |str|
-            loc = str.location
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
 
-            if str.heredoc?
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
               ranges << loc.heredoc_body
             elsif loc.respond_to?(:begin) && loc.begin
               ranges << loc.expression
             end
           end
-          ranges
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           comments.map(&:loc).map(&:expression)
@@ -119,7 +123,7 @@ module RuboCop
         end
 
         def ignored_ranges
-          @ignored_ranges ||= string_literal_ranges(processed_source.ast) +
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
                               comment_ranges(processed_source.comments)
         end
 

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -50,9 +50,9 @@ module RuboCop
 
         def on_send(node)
           # Include "the whole expression".
-          node = node.parent while convertible_block?(node) ||
-                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
-                                   node.parent&.send_type?
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
@@ -69,15 +69,14 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node) do |corrector|
-            corrector.replace(node.source_range, to_single_line(node.source).strip)
+            corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
         def offense?(node)
-          return false if configured_to_not_be_inspected?(node)
-
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
+            !configured_to_not_be_inspected?(node)
         end
 
         def configured_to_not_be_inspected?(node)

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -102,7 +102,7 @@ module RuboCop
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -196,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end