Simplify now that corrector accept node arguments and/or allow wrap

lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -53,7 +53,7 @@ def on_send(node)
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(
-              node.first_argument.loc.expression, "'https://rubygems.org'"
+              node.first_argument, "'https://rubygems.org'"
             )
           end
         end

lib/rubocop/cop/correctors/condition_corrector.rb

@@ -10,8 +10,7 @@ def correct_negative_condition(node)
 
           lambda do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
-            corrector.replace(condition.source_range,
-                              condition.children.first.source)
+            corrector.replace(condition, condition.children.first.source)
           end
         end
 

lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -18,7 +18,7 @@ def correct(node)
         end
 
         def insert_before(node)
-          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+          ->(corrector) { corrector.insert_before(node, "\n") }
         end
       end
     end

lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -44,13 +44,13 @@ def insert_separating_space(corrector)
       end
 
       def replace_selector(corrector)
-        corrector.replace(method.source_range, 'lambda')
+        corrector.replace(method, 'lambda')
       end
 
       def remove_arguments(corrector)
         return if arguments.empty_and_without_delimiters?
 
-        corrector.remove(arguments.source_range)
+        corrector.remove(arguments)
       end
 
       def insert_arguments(corrector)
@@ -62,7 +62,7 @@ def insert_arguments(corrector)
 
       def remove_leading_whitespace(corrector)
         corrector.remove_preceding(
-          arguments.source_range,
+          arguments,
           arguments.source_range.begin_pos -
             block_node.send_node.source_range.end_pos
         )

lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -38,9 +38,9 @@ def move_comment(eol_comment:, node:, corrector:)
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
+          corrector.insert_before(node,
                                   text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
+          corrector.remove(eol_comment)
         end
 
         private

lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -26,7 +26,7 @@ def correct(node, char)
       def wrap_contents(node, contents, char, delimiters)
         lambda do |corrector|
           corrector.replace(
-            node.source_range,
+            node,
             "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
           )
         end

lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -13,9 +13,9 @@ def correct(node, style)
           lambda do |corrector|
             str = node.str_content
             if style == :single_quotes
-              corrector.replace(node.source_range, to_string_literal(str))
+              corrector.replace(node, to_string_literal(str))
             else
-              corrector.replace(node.source_range, str.inspect)
+              corrector.replace(node, str.inspect)
             end
           end
         end

lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -28,7 +28,7 @@ def on_send(node)
         def autocorrect(node)
           (*, keyword) = offending_location_argument(node.parent)
 
-          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+          ->(corrector) { corrector.replace(node, ":#{keyword}") }
         end
 
         private

lib/rubocop/cop/layout/dot_position.rb

@@ -44,7 +44,7 @@ def autocorrect(node)
             when :leading
               corrector.insert_before(selector_range(node), dot)
             when :trailing
-              corrector.insert_after(node.receiver.source_range, dot)
+              corrector.insert_after(node.receiver, dot)
             end
           end
         end

lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -169,7 +169,7 @@ def fix_closing_parenthesis(node, corrector)
         end
 
         def add_correct_closing_paren(node, corrector)
-          corrector.insert_after(node.arguments.last.source_range, ')')
+          corrector.insert_after(node.arguments.last, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -249,7 +249,7 @@ def fix_external_trailing_comma(node, corrector)
         def add_correct_external_trailing_comma(node, corrector)
           return unless external_trailing_comma?(node)
 
-          corrector.insert_after(node.arguments.last.source_range, ',')
+          corrector.insert_after(node.arguments.last, ',')
         end
 
         def remove_incorrect_external_trailing_comma(node, corrector)

lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -184,14 +184,14 @@ def adjust_squiggly(corrector, node)
         def adjust_minus(corrector, node)
           heredoc_beginning = node.loc.expression.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
-          corrector.replace(node.loc.expression, corrected)
+          corrector.replace(node, corrected)
         end
 
         def correct_by_library(node)
           lambda do |corrector|
             corrector.replace(node.loc.heredoc_body, indented_body(node))
             corrected = ".#{STRIP_METHODS[style]}"
-            corrector.insert_after(node.loc.expression, corrected)
+            corrector.insert_after(node, corrected)
           end
         end
 

lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -129,7 +129,7 @@ def autocorrect_body(corrector, node, block_body)
 
           block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node.source_range,
+          corrector.insert_before(first_node,
                                   "\n  #{' ' * block_start_col}")
         end
 

lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -43,9 +43,9 @@ def autocorrect(target)
           lambda do |corrector|
             if target.is_a?(RuboCop::AST::Node)
               if target.parent.children.first == target
-                corrector.insert_before(target.source_range, ' ')
+                corrector.insert_before(target, ' ')
               else
-                corrector.insert_after(target.source_range, ' ')
+                corrector.insert_after(target, ' ')
               end
             elsif target.source =~ /^\s+$/
               corrector.remove(target)

lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -46,7 +46,7 @@ def autocorrect(lambda_node)
           children = lambda_node.parent.children
           lambda do |corrector|
             if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
+              corrector.insert_before(children[1], ' ')
             else
               corrector.remove(space_after_arrow(lambda_node))
             end

lib/rubocop/cop/layout/space_inside_range_literal.rb

@@ -35,7 +35,7 @@ def autocorrect(node)
 
           lambda do |corrector|
             corrector.replace(
-              node.source_range,
+              node,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)

lib/rubocop/cop/lint/boolean_symbol.rb

@@ -41,7 +41,7 @@ def autocorrect(node)
               corrector.remove(parent.loc.operator)
               boolean_literal = "#{node.source} =>"
             end
-            corrector.replace(node.loc.expression, boolean_literal)
+            corrector.replace(node, boolean_literal)
           end
         end
       end

lib/rubocop/cop/lint/inherit_exception.rb

@@ -77,7 +77,7 @@ def on_send(node)
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, preferred_base_class)
+            corrector.replace(node, preferred_base_class)
           end
         end
 

lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -37,7 +37,7 @@ def autocorrect(node)
           return if node.dstr_type? # nested, fixed in next iteration
 
           value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+          ->(corrector) { corrector.replace(node.parent, value) }
         end
 
         private

lib/rubocop/cop/lint/multiple_comparison.rb

@@ -39,7 +39,7 @@ def autocorrect(node)
           new_center = "#{center.source} && #{center.source}"
 
           lambda do |corrector|
-            corrector.replace(center.source_range, new_center)
+            corrector.replace(center, new_center)
           end
         end
       end

lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -52,12 +52,12 @@ def on_block(node)
         def autocorrect(node)
           if unsorted_dir_block?(node)
             lambda do |corrector|
-              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
+              corrector.replace(node, "#{node.source}.sort.each")
             end
           else
             lambda do |corrector|
               source = node.receiver.source
-              corrector.replace(node.loc.expression, "#{source}.sort.each")
+              corrector.replace(node, "#{source}.sort.each")
             end
           end
         end

lib/rubocop/cop/lint/number_conversion.rb

@@ -55,7 +55,7 @@ def on_send(node)
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression,
+            corrector.replace(node,
                               correct_method(node, node.receiver))
           end
         end

lib/rubocop/cop/lint/redundant_string_coercion.rb

@@ -38,7 +38,7 @@ def autocorrect(node)
           lambda do |corrector|
             receiver = node.receiver
             corrector.replace(
-              node.source_range,
+              node,
               if receiver
                 receiver.source
               else

lib/rubocop/cop/lint/uri_regexp.rb

@@ -54,7 +54,7 @@ def autocorrect(node)
             argument = arg ? "(#{arg.source})" : ''
 
             corrector.replace(
-              node.loc.expression,
+              node,
               "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
             )
           end

lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -161,7 +161,7 @@ def set_new_arg_name(transformed_argname, corrector)
 
         def set_new_body_expression(transforming_body_expr, corrector)
           corrector.replace(
-            block_node.body.loc.expression,
+            block_node.body,
             transforming_body_expr.loc.expression.source
           )
         end

lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -73,7 +73,7 @@ def autocorrect(node)
             node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
-              corrector.replace(var.loc.expression, preferred_name)
+              corrector.replace(var, preferred_name)
             end
           end
         end

lib/rubocop/cop/style/alias.rb

@@ -115,7 +115,7 @@ def correct_alias_method_to_alias(send_node)
           lambda do |corrector|
             new, old = *send_node.arguments
             replacement = "alias #{identifier(new)} #{identifier(old)}"
-            corrector.replace(send_node.source_range, replacement)
+            corrector.replace(send_node, replacement)
           end
         end
 
@@ -125,15 +125,15 @@ def correct_alias_to_alias_method(node)
               'alias_method ' \
               ":#{identifier(node.new_identifier)}, " \
               ":#{identifier(node.old_identifier)}"
-            corrector.replace(node.source_range, replacement)
+            corrector.replace(node, replacement)
           end
         end
 
         def correct_alias_with_symbol_args(node)
           lambda do |corrector|
-            corrector.replace(node.new_identifier.source_range,
+            corrector.replace(node.new_identifier,
                               node.new_identifier.source[1..-1])
-            corrector.replace(node.old_identifier.source_range,
+            corrector.replace(node.old_identifier,
                               node.old_identifier.source[1..-1])
           end
         end

lib/rubocop/cop/style/and_or.rb

@@ -97,12 +97,12 @@ def correct_send(node, corrector)
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         # ! is a special case:
@@ -124,8 +124,7 @@ def correct_not(node, receiver, corrector)
         def correct_other(node, corrector)
           return if node.source_range.begin.is?('(')
 
-          corrector.insert_before(node.source_range, '(')
-          corrector.insert_after(node.source_range, ')')
+          corrector.wrap(node, '(', ')')
         end
 
         def correctable_send?(node)

lib/rubocop/cop/style/array_join.rb

@@ -30,7 +30,7 @@ def autocorrect(node)
           array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+            corrector.replace(node, "#{array}.join(#{join_arg})")
           end
         end
       end

lib/rubocop/cop/style/character_literal.rb

@@ -33,9 +33,9 @@ def autocorrect(node)
             # special character like \n
             # or ' which needs to use "" or be escaped.
             if string.length == 2 || string == "'"
-              corrector.replace(node.source_range, %("#{string}"))
+              corrector.replace(node, %("#{string}"))
             elsif string.length == 1 # normal character
-              corrector.replace(node.source_range, "'#{string}'")
+              corrector.replace(node, "'#{string}'")
             end
           end
         end