rubocop 1.88.2 → 1.90.0

data/lib/rubocop/cop/style/negated_if_else_condition.rb

@@ -46,7 +46,7 @@ module RuboCop
           @corrected_nodes = nil
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
@@ -64,7 +64,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 

data/lib/rubocop/cop/style/negative_array_index.rb

@@ -91,8 +91,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def range_with_length_subtraction?(range_node, array_receiver)
-          return false unless range_node.range_type?
+          return false unless range_node&.range_type?
 
           range_end = range_node.end
           range_start = range_node.begin
@@ -122,7 +123,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index,
                                      index_arg)
           range_op = range_node.erange_type? ? '...' : '..'
@@ -138,7 +139,6 @@ module RuboCop
 
           [message, replacement]
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def format_range_message_parts(range_start, negative_index, index_arg)
           has_parentheses = index_arg.begin_type?

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -42,7 +42,7 @@ module RuboCop
         # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless node.receiver
 
@@ -61,7 +61,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/style/operator_method_call.rb

@@ -26,7 +26,7 @@ module RuboCop
           splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
         ].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
           return if unary_method_no_operator?(node)
@@ -44,7 +44,6 @@ module RuboCop
             corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

data/lib/rubocop/cop/style/parallel_assignment.rb

@@ -184,9 +184,8 @@ module RuboCop
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
               # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              # rubocop:disable Performance/RedundantEqualityComparisonBlock
+              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock
               matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
-              # rubocop:enable Performance/RedundantEqualityComparisonBlock
             else
               access_method = lhs.method_name.to_s.chop.to_sym
               matching_calls(rhs, lhs.receiver, access_method).any?

data/lib/rubocop/cop/style/redundant_assignment.rb

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for redundant assignment before returning.
       #
+      # When there are comments between the assignment and reference,
+      # the cop will report an offense but it will not autocorrect.
+      #
       # @example
       #   # bad
       #   def test
@@ -54,7 +57,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
@@ -69,7 +72,6 @@ module RuboCop
             check_begin_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_case_node(node)
           node.when_branches.each { |when_node| check_branch(when_node.body) }
@@ -99,6 +101,8 @@ module RuboCop
         def check_begin_node(node)
           if (assignment = redundant_assignment?(node))
             add_offense(assignment) do |corrector|
+              next if comments_between_assignment_and_reference?(assignment)
+
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
               corrector.remove(assignment.right_sibling)
@@ -108,6 +112,12 @@ module RuboCop
             check_branch(last_expr)
           end
         end
+
+        def comments_between_assignment_and_reference?(assignment)
+          line_span = assignment.source_range.line..assignment.right_sibling.source_range.line
+
+          processed_source.each_comment_in_lines(line_span).any?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -180,7 +180,7 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def if_branch_is_true_type_and_else_is_not?(node)
           return false unless node.ternary? || node.if?
 
@@ -190,7 +190,6 @@ module RuboCop
 
           node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def branches_have_assignment?(node)
           _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
@@ -240,7 +239,7 @@ module RuboCop
           "#{method.source}(#{arguments.source})"
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
@@ -257,7 +256,6 @@ module RuboCop
             if_branch.source
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
           if arithmetic_operation

data/lib/rubocop/cop/style/redundant_constant_base.rb

@@ -14,6 +14,11 @@ module RuboCop
       # to prevent conflicting rules. This is because it respects user configurations
       # that want to enable `Lint/ConstantResolution` cop which is disabled by default.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, a leading `::` inside a namespace is also reported when the
+      # constant provably resolves to the same declaration with and without
+      # the base, i.e. nothing in the surrounding nesting shadows it.
+      #
       # @example
       #   # bad
       #   ::Const
@@ -41,13 +46,14 @@ module RuboCop
       #     ::Const
       #   end
       class RedundantConstantBase < Base
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Remove redundant `::`.'
 
         def on_cbase(node)
           return if lint_constant_resolution_cop_enabled?
-          return unless bad?(node)
+          return unless bad?(node) || provably_unshadowed?(node)
 
           add_offense(node) do |corrector|
             corrector.remove(node)
@@ -56,6 +62,36 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, `::` inside a namespace is
+        # also redundant when the first constant segment resolves to the same
+        # declaration with and without the base, i.e. nothing in the
+        # surrounding nesting shadows it.
+        def provably_unshadowed?(node)
+          return false unless project_index
+          return false unless (segment = first_constant_segment(node))
+
+          nesting = module_nesting_ancestors_of(node)
+                    .map { |ancestor| ancestor.identifier.const_name }.reverse
+
+          !nesting.empty? && same_resolution?(segment, nesting)
+        rescue StandardError
+          false
+        end
+
+        def same_resolution?(segment, nesting)
+          relative = project_index.resolve_constant(segment, nesting)
+          absolute = project_index.resolve_constant(segment, [])
+
+          !relative.nil? && !absolute.nil? && relative.name == absolute.name
+        end
+
+        def first_constant_segment(node)
+          parent = node.parent
+          return nil unless parent&.const_type?
+
+          parent.short_name.to_s
+        end
+
         def lint_constant_resolution_cop_enabled?
           lint_constant_resolution_config.fetch('Enabled', false)
         end

data/lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb

@@ -25,7 +25,7 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
@@ -38,7 +38,6 @@ module RuboCop
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

data/lib/rubocop/cop/style/redundant_each.rb

@@ -60,7 +60,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_each_method(node)
           return if node.last_argument&.block_pass_type?
 
@@ -81,7 +81,6 @@ module RuboCop
 
           prev_method if detected || prev_method.method?(:reverse_each)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def range(node)
           return node.selector unless node.method?(:each)

data/lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -41,6 +41,10 @@ module RuboCop
             return unless name_node.value.end_with?('.rb')
 
             extension_range = extension_range(name_node)
+            # A backslash right before the extension means the path is escaped;
+            # dropping the extension would either produce invalid Ruby (a trailing
+            # backslash escaping the closing quote) or a confusing path, so skip it.
+            return if escaped_extension?(name_node, extension_range)
 
             add_offense(extension_range) do |corrector|
               corrector.remove(extension_range)
@@ -55,6 +59,11 @@ module RuboCop
 
           range_between(end_of_path_string - 4, end_of_path_string - 1)
         end
+
+        def escaped_extension?(name_node, extension_range)
+          offset = extension_range.begin_pos - name_node.source_range.begin_pos
+          name_node.source[0...offset].end_with?('\\')
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_format.rb

@@ -155,7 +155,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def all_fields_literal?(string, arguments)
           count = 0
           sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
@@ -175,18 +175,17 @@ module RuboCop
 
           sequences.size == count
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # If the sequence has a variable (`*`) width, it cannot be autocorrected
         # if the width is not given as a numeric literal argument
         def unknown_variable_width?(sequence, arguments)
           return false unless sequence.variable_width?
 
-          argument = arguments[sequence.variable_width_argument_number - 1]
-          !numeric?(argument)
+          argument = positional_argument(arguments, sequence.variable_width_argument_number)
+          argument.nil? || !numeric?(argument)
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def find_argument(sequence, arguments, hash)
           if hash && (sequence.annotated? || sequence.template?)
             find_hash_value_node(hash, sequence.name.to_sym).first
@@ -195,12 +194,11 @@ module RuboCop
             arguments.delete_at(sequence.variable_width_argument_number - 1)
             arguments.shift
           elsif sequence.arg_number
-            arguments[sequence.arg_number.to_i - 1]
+            positional_argument(arguments, sequence.arg_number.to_i)
           else
             arguments.shift
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def matching_argument?(sequence, argument)
           # Template specifiers don't give a type, any acceptable literal type is ok.
@@ -220,6 +218,15 @@ module RuboCop
           end
         end
 
+        # `Array#[]` raises `RangeError` for an index beyond the 64-bit range
+        # (e.g. `format('%*9999999999999999999999$d', 1)`) instead of returning `nil`,
+        # so the index needs to be checked before accessing the array.
+        def positional_argument(arguments, number)
+          index = number - 1
+
+          arguments[index] if index < arguments.size
+        end
+
         def numeric?(argument)
           argument.type?(:numeric, :str) ||
             rational_number?(argument) ||

data/lib/rubocop/cop/style/redundant_line_continuation.rb

@@ -5,10 +5,13 @@ module RuboCop
     module Style
       # Checks for redundant line continuation.
       #
-      # This cop marks a line continuation as redundant if removing the backslash
-      # does not result in a syntax error.
-      # However, a backslash at the end of a comment or
-      # for string concatenation is not redundant and is not considered an offense.
+      # A line continuation is redundant when removing the backslash does not
+      # change how the program parses: the source is reparsed without the
+      # backslash and the resulting AST is compared to the original. Only
+      # backslashes that are pure noise are reported; backslashes that are
+      # significant — inside strings, for string concatenation, before an
+      # operator or argument that would otherwise start a new statement, and
+      # so on — are left alone, as are backslashes in comments.
       #
       # @example
       #   # bad
@@ -66,31 +69,23 @@ module RuboCop
       #
       class RedundantLineContinuation < Base
         include MatchRange
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
         LINE_CONTINUATION = '\\'
         LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
-        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
-        ARGUMENT_TYPES = %i[
-          kDEF kDEFINED kFALSE kNIL kSELF kTRUE tAMPER tBANG tCARET tCHARACTER tCOLON3 tCONSTANT
-          tCVAR tDOT2 tDOT3 tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR tLAMBDA tLBRACK tLCURLY
-          tLPAREN_ARG tPIPE tQSYMBOLS_BEG tQWORDS_BEG tREGEXP_BEG tSTAR tSTRING tSTRING_BEG tSYMBEG
-          tSYMBOL tSYMBOLS_BEG tTILDE tUMINUS tUNARY_NUM tUPLUS tWORDS_BEG tXSTRING_BEG
-        ].freeze
-        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[
-          tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
-        ].freeze
-        ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
-        STRING_LITERAL_BEGIN_TOKENS = %i[tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tSYMBEG].freeze
+        STRING_TOKEN_TYPES = %i[tSTRING tSTRING_CONTENT].freeze
+        STRING_LITERAL_ENDING_TOKEN_TYPES = %i[tSTRING tSTRING_END].freeze
+        STRING_LITERAL_BEGINNING_TOKEN_TYPES = %i[tSTRING tSTRING_BEG].freeze
 
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
-            next if require_line_continuation?(range)
-            next unless redundant_line_continuation?(range)
-
+          # A backslash is redundant if the source parses to the same AST
+          # without it; verification is the offense logic itself, so oversized
+          # scopes are reparsed regardless of size.
+          verified_by_reparse(line_continuation_candidates, oversized: :verify).each do |range|
             add_offense(range) do |corrector|
               corrector.remove_leading(range, 1)
             end
@@ -101,87 +96,100 @@ module RuboCop
 
         private
 
-        def require_line_continuation?(range)
-          !ends_with_uncommented_backslash?(range) ||
-            string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(range) ||
-            inside_string_literal_or_method_with_argument?(range) ||
-            inside_string_literal_with_interpolation?(range) ||
-            leading_dot_method_chain_with_blank_line?(range)
+        def apply_reparse_correction(corrector, range)
+          corrector.remove_leading(range, 1)
         end
 
-        def ends_with_uncommented_backslash?(range)
-          # A line continuation always needs to be the last character on the line, which
-          # means that it is impossible to have a comment following a continuation.
-          # Therefore, if the line contains a comment, it cannot end with a continuation.
-          return false if processed_source.line_with_comment?(range.line)
+        def line_continuation_candidates
+          candidates = []
+
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
+            next if within_comment?(range) || implicit_string_concatenation?(range)
+            next if within_string_content?(range)
+            next if leading_dot_method_chain_with_blank_line?(range)
+
+            candidates << range
+          end
 
-          range.source_line.end_with?(LINE_CONTINUATION)
+          candidates
         end
 
-        def string_concatenation?(source_line)
-          /["']\s*\\\z/.match?(source_line)
+        def within_comment?(range)
+          processed_source.comments.any? do |comment|
+            comment.source_range.overlaps?(range)
+          end
         end
 
-        def inside_string_literal_or_method_with_argument?(range)
-          line_range = range_by_whole_lines(range)
+        # A backslash directly joining two string literals is never redundant:
+        # removing it moves the second literal onto its own logical line,
+        # severing the implicit string concatenation. Skipping these up front
+        # avoids reparse verification, which is prohibitively slow on generated
+        # files gluing thousands of string fragments with line continuations.
+        def implicit_string_concatenation?(range)
+          tokens = processed_source.sorted_tokens
 
-          processed_source.tokens.each_cons(2).any? do |token, next_token|
-            next if token.line == next_token.line
+          token_before = last_token_before(tokens, range)
+          return false unless string_literal_ending_on_line?(token_before, range.line)
 
-            inside_string_literal?(range, token) ||
-              method_with_argument?(line_range, token, next_token)
-          end
+          string_literal_beginning_on_line?(first_token_after(tokens, range), range.line + 1)
         end
 
-        def inside_string_literal_with_interpolation?(range)
-          string_depth = 0
-          processed_source.tokens.each do |token|
-            break if token.pos.begin_pos >= range.begin_pos
-
-            if STRING_LITERAL_BEGIN_TOKENS.include?(token.type)
-              string_depth += 1
-            elsif token.type == :tSTRING_END
-              string_depth -= 1
-            end
+        # A backslash in string content is never a redundant line continuation
+        # (removing it changes the string's value, which the reparse check would
+        # detect); skipping it up front just avoids a useless reparse.
+        def within_string_content?(range)
+          @string_content_ranges ||= processed_source.tokens.filter_map do |token|
+            token.pos if STRING_TOKEN_TYPES.include?(token.type)
           end
-          string_depth.positive?
+
+          @string_content_ranges.any? { |pos| pos.overlaps?(range) }
         end
 
+        # The `parser` gem, unlike Ruby itself, accepts a leading-dot method
+        # chain continued across a blank line, so the reparse check alone would
+        # deem the backslash redundant even though removing it breaks the code
+        # on MRI. Prism matches Ruby here and does not need this guard.
         def leading_dot_method_chain_with_blank_line?(range)
           return false unless range.source_line.strip.start_with?('.', '&.')
 
           processed_source[range.line].strip.empty?
         end
 
-        def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.last_line))
-          return false if argument_newline?(node)
+        def last_token_before(tokens, range)
+          index = tokens.bsearch_index { |token| token.end_pos > range.begin_pos }
+          index&.positive? ? tokens[index - 1] : nil
+        end
+
+        def first_token_after(tokens, range)
+          tokens.bsearch { |token| token.begin_pos >= range.end_pos }
+        end
+
+        def string_literal_ending_on_line?(token, line)
+          return false unless token
+
+          STRING_LITERAL_ENDING_TOKEN_TYPES.include?(token.type) && token.pos.last_line == line
+        end
+
+        def string_literal_beginning_on_line?(token, line)
+          return false unless token
 
-          # Check if source is still valid without the continuation
-          source = processed_source.raw_source.dup
-          source[range.begin_pos, range.length] = "\n"
-          parse(source).valid_syntax?
+          STRING_LITERAL_BEGINNING_TOKEN_TYPES.include?(token.type) && token.line == line
         end
 
         def inspect_end_of_ruby_code_line_continuation
           last_line_number = processed_source.ast.last_line
           last_line = processed_source.lines[last_line_number - 1]
-          return unless code_ends_with_continuation?(last_line)
+          return unless last_line&.end_with?(LINE_CONTINUATION)
 
-          line_continuation_range = trailing_line_continuation_range(last_line_number)
+          range = trailing_line_continuation_range(last_line_number)
+          return if within_comment?(range)
+          return if verified_by_reparse([range], oversized: :verify).empty?
 
-          add_offense(line_continuation_range) do |corrector|
-            corrector.remove_trailing(line_continuation_range, 1)
+          add_offense(range) do |corrector|
+            corrector.remove_trailing(range, 1)
           end
         end
 
-        def code_ends_with_continuation?(last_line)
-          return false if processed_source.line_with_comment?(processed_source.ast.last_line)
-
-          last_line.end_with?(LINE_CONTINUATION)
-        end
-
         # The backslash is the last character of the line; locate it by the line's
         # position in the buffer rather than treating the column as an absolute offset
         # (which corrupts an earlier line in multi-line files).
@@ -189,71 +197,6 @@ module RuboCop
           line_range = processed_source.buffer.line_range(line_number)
           range_between(line_range.end_pos - 1, line_range.end_pos)
         end
-
-        def inside_string_literal?(range, token)
-          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
-        end
-
-        # A method call without parentheses such as the following cannot remove `\`:
-        #
-        #   do_something \
-        #     argument
-        def method_with_argument?(line_range, current_token, next_token)
-          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
-          return false unless current_token.pos.overlaps?(line_range)
-
-          ARGUMENT_TYPES.include?(next_token.type)
-        end
-
-        def argument_newline?(node)
-          return false if node.parenthesized_call?
-
-          node = node.children.first if node.root? && node.begin_type?
-
-          if argument_is_method?(node)
-            argument_newline?(node.first_argument)
-          else
-            return false unless method_call_with_arguments?(node)
-
-            node.loc.selector.line != node.first_argument.loc.line
-          end
-        end
-
-        def find_node_for_line(last_line)
-          processed_source.ast.each_node do |node|
-            return node if same_line?(node, last_line)
-          end
-        end
-
-        def same_line?(node, line)
-          return false unless (source_range = node.source_range)
-
-          if node.is_a?(AST::StrNode)
-            if node.heredoc?
-              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
-            else
-              (source_range.line..source_range.last_line).cover?(line)
-            end
-          else
-            source_range.line == line
-          end
-        end
-
-        def argument_is_method?(node)
-          return false unless node.send_type?
-          return false unless (first_argument = node.first_argument)
-
-          method_call_with_arguments?(first_argument)
-        end
-
-        def method_call_with_arguments?(node)
-          node.call_type? && !node.arguments.empty?
-        end
-
-        def start_with_arithmetic_operator?(range)
-          line_range = processed_source.buffer.line_range(range.line + 1)
-          ARITHMETIC_OPERATOR_TOKENS.include?(processed_source.first_token_of(line_range).type)
-        end
       end
     end
   end