rubocop 1.87.0 → 1.88.2

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

@@ -6,6 +6,14 @@ module RuboCop
       # Checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
+      # When the `Recursive` option is enabled, mutable literals nested inside
+      # arrays and hashes are also frozen, so an offense on the outermost
+      # unfrozen literal will autocorrect every nested mutable literal as well.
+      # When the outer literal already has `.freeze` appended, the cop descends
+      # into it and reports each outermost unfrozen literal underneath. The
+      # option is disabled by default to preserve existing behavior; opt in to
+      # get strict nested freezing.
+      #
       # Strict mode can be used to freeze all constants, rather than
       # just literals.
       # Strict mode is considered an experimental feature. It has not been
@@ -49,6 +57,17 @@ module RuboCop
       #   CONST = Something.new
       #
       #
+      # @example Recursive: false (default)
+      #   # good - only the outer container needs to be frozen
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      # @example Recursive: true
+      #   # bad - nested mutable literals must be frozen too
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      #   # good
+      #   CONST = [{ a: [].freeze, b: 'foo'.freeze }.freeze].freeze
+      #
       # @example EnforcedStyle: strict
       #   # bad
       #   CONST = Something.new
@@ -138,10 +157,30 @@ module RuboCop
         private
 
         def on_assignment(value)
-          if style == :strict
-            strict_check(value)
+          nodes = mutable_nodes(value) do |node|
+            if style == :strict
+              strict_check(node)
+            else
+              literal_check(node)
+            end
+          end
+
+          nodes.each do |node|
+            add_offense(node) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        def mutable_nodes(value, &block)
+          if recursive? && explicitly_frozen_literal?(value)
+            literal_children(value.receiver).flat_map { |c| mutable_nodes(c, &block) }
           else
-            check(value)
+            node_offending = yield(value)
+
+            if node_offending
+              [value]
+            else
+              []
+            end
           end
         end
 
@@ -151,18 +190,20 @@ module RuboCop
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
         end
 
-        def check(value)
-          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
-          return unless mutable_literal?(value) ||
-                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
-
+        def literal_check(value)
+          return unless mutable_or_unfrozen_range?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
+        end
+
+        def mutable_or_unfrozen_range?(value)
+          mutable_literal?(value) ||
+            (target_ruby_version <= 2.7 && range_enclosed_in_parentheses?(value))
         end
 
         def autocorrect(corrector, node)
@@ -171,13 +212,66 @@ module RuboCop
           splat_value = splat_value(node)
           if splat_value
             correct_splat_expansion(corrector, expr, splat_value)
-          elsif node.array_type? && !node.bracketed?
+            corrector.insert_after(expr, '.freeze')
+            return
+          end
+
+          if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
 
           corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        # Recursively freezes every nested mutable literal inside an array or
+        # hash literal. Already-frozen subtrees are not re-frozen, but their
+        # children are still inspected for unfrozen literals deeper down.
+        def freeze_nested_literals(corrector, node)
+          literal_children(node).each do |child|
+            if explicitly_frozen_literal?(child)
+              freeze_nested_literals(corrector, child.receiver)
+            elsif freezable_nested_literal?(child)
+              autocorrect(corrector, child)
+            end
+          end
+        end
+
+        def freezable_nested_literal?(node)
+          return false if frozen_string_literal?(node)
+          return false if shareable_constant_value?(node)
+
+          mutable_literal?(node)
+        end
+
+        # Returns the child literals of an array or hash node that may
+        # themselves need freezing. For hashes, both keys and values are
+        # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
+        # `.freeze` cannot be appended to their contents.
+        def literal_children(node)
+          case node.type
+          when :array
+            return [] if node.percent_literal?
+
+            node.children
+          when :hash
+            node.children.flat_map { |child| child.pair_type? ? child.children : [] }
+          else
+            []
+          end
+        end
+
+        def explicitly_frozen_literal?(node)
+          return false unless node.send_type? && node.method?(:freeze)
+
+          node.receiver && mutable_literal?(node.receiver)
+        end
+
+        def recursive?
+          cop_config.fetch('Recursive', false)
         end
 
         def mutable_literal?(value)

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

@@ -6,6 +6,11 @@ module RuboCop
       # Checks for lambdas and procs that always return nil,
       # which can be replaced with an empty lambda or proc instead.
       #
+      # NOTE: A `proc` that returns nil via an explicit `return` is allowed,
+      # because in a `proc` `return` exits the enclosing method, so removing it
+      # would change behavior. A lambda is still reported, since there `return`
+      # only exits the lambda itself.
+      #
       # @example
       #   # bad
       #   -> { nil }
@@ -46,6 +51,9 @@ module RuboCop
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
+          # `return` inside a non-lambda proc returns from the enclosing method,
+          # so dropping it changes behavior; only a lambda can omit it safely.
+          return if node.body.return_type? && !node.lambda?
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
           add_offense(node, message: message) do |corrector|

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

@@ -92,7 +92,7 @@ module RuboCop
           return unless numeric
 
           return if allowed_method_name?(node.method_name) ||
-                    node.each_ancestor(:send, :block).any? do |ancestor|
+                    node.each_ancestor(:send, :any_block).any? do |ancestor|
                       allowed_method_name?(ancestor.method_name)
                     end
 

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

@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          parent.type?(:class, :module) && node.left_siblings.empty?
+          parent&.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -46,7 +46,7 @@ module RuboCop
         end
 
         def super_used?(node)
-          node.parent.each_node(:zsuper).any?
+          node.parent.each_node(:zsuper, :super).any?
         end
       end
     end

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

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
         end
+        alias on_defs on_def
 
         private
 

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

@@ -38,7 +38,7 @@ module RuboCop
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
-                    allowed_masign?(node.assignments, rhs_elements)
+                    allowed_masign?(node.assignments, rhs_elements) || contains_heredoc?(rhs)
 
           range = node.source_range.begin.join(rhs.source_range.end)
 
@@ -77,6 +77,13 @@ module RuboCop
           !node.array_type? || elements.any?(&:splat_type?)
         end
 
+        # Autocorrection splits the assignment into single assignments on
+        # consecutive lines, which would put following assignments into the
+        # heredoc body unless the heredoc bodies were moved along.
+        def contains_heredoc?(node)
+          node.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def assignment_corrector(node, rhs, order)
           if node.parent&.rescue_type?
             _assignment, modifier = *node.parent
@@ -226,14 +233,23 @@ module RuboCop
           def source(node, loc)
             # __FILE__ is treated as a StrNode but has no begin
             if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
-              "'#{node.source}'"
+              # `%w` elements have no per-element delimiter, so the value must be
+              # quoted and escaped to stay valid (e.g. `%w(it's)` -> `'it\'s'`).
+              quote(node.value)
             elsif node.sym_type? && !node.loc?(:begin)
-              ":#{node.source}"
+              # `%i` elements have no per-element delimiter, so a symbol that needs
+              # quoting must be emitted as `:"..."` (e.g. `%i(foo-bar)` -> `:"foo-bar"`),
+              # otherwise `:foo-bar` would parse as `:foo.-(bar)`.
+              node.value.inspect
             else
               node.source
             end
           end
 
+          def quote(string)
+            "'#{string.gsub(/[\\']/) { |char| "\\#{char}" }}'"
+          end
+
           def extract_sources(node)
             node.children.map(&:source)
           end

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

@@ -101,6 +101,8 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node.scrub
+          elsif node.is_a?(Symbol)
+            node.to_s
           elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
-      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
+      # $1, $2, $&, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -69,6 +69,10 @@ module RuboCop
         # @return [String, nil]
         def preferred_expression_to(node)
           first = node.to_a.first
+          # NOTE: `$+` / `$LAST_PAREN_MATCH` is deliberately not converted. It
+          # refers to the last group that actually matched, which has no concise
+          # `Regexp.last_match` equivalent (`Regexp.last_match(-1)` is the last
+          # group in the pattern, which may be `nil`).
           case first
           when ::Integer
             "Regexp.last_match(#{first})"
@@ -78,8 +82,6 @@ module RuboCop
             'Regexp.last_match.pre_match'
           when :$', :$POSTMATCH
             'Regexp.last_match.post_match'
-          when :$+, :$LAST_PAREN_MATCH
-            'Regexp.last_match(-1)'
           end
         end
 

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

@@ -26,7 +26,9 @@ module RuboCop
         def on_send(node)
           return unless (first_argument = node.first_argument)
           return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
-          return unless (redundant_length = redundant_path_length(first_argument.str_content))
+
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
           end_pos = begin_pos + redundant_length
@@ -39,6 +41,16 @@ module RuboCop
 
         private
 
+        # The literal text at the start of the path, which is the whole string
+        # for a plain string and the leading literal segment for an interpolated
+        # one (`nil` when it starts with interpolation).
+        def leading_path_content(node)
+          return node.str_content if node.str_type?
+          return unless node.dstr_type? && (first = node.children.first)&.str_type?
+
+          first.str_content
+        end
+
         def redundant_path_length(path)
           return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
 

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

@@ -38,6 +38,10 @@ module RuboCop
 
         def fix_exploded(node)
           exploded?(node) do |command, message|
+            # `raise RuntimeError, nil` uses the class name as the message, so
+            # rewriting it to `raise nil.to_s` (an empty message) would change it.
+            next if message.nil_type?
+
             add_offense(node, message: MSG_1) do |corrector|
               corrector.replace(node, replaced_exploded(node, command, message))
             end
@@ -56,6 +60,8 @@ module RuboCop
 
         def fix_compact(node)
           compact?(node) do |new_call, message|
+            next if message.nil_type?
+
             add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, replaced_compact(message))
             end

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

@@ -62,7 +62,7 @@ module RuboCop
         def_node_matcher :select_predicate?, <<~PATTERN
           (call
             {
-              (block $(call _ {:select :filter :find_all}) ...)
+              (any_block $(call _ {:select :filter :find_all}) ...)
               $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})

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

@@ -89,6 +89,8 @@ module RuboCop
 
         def on_send(node)
           format_without_additional_args?(node) do |value|
+            next if string_with_format_sequence?(value)
+
             replacement = escape_control_chars(value.source)
 
             add_offense(node, message: message(node, replacement)) do |corrector|
@@ -102,12 +104,31 @@ module RuboCop
 
         private
 
+        # A single-argument `format` whose string still contains a format sequence is
+        # not redundant: `format('%s')` raises at runtime, and `format('%%')` returns
+        # `'%'`, so replacing it with the literal would change behavior.
+        def string_with_format_sequence?(node)
+          string = static_string_value(node)
+          return false unless string
+
+          RuboCop::Cop::Utils::FormatString.new(string).format_sequences.any?
+        end
+
+        def static_string_value(node)
+          if node.str_type?
+            node.value
+          elsif node.dstr_type?
+            node.children.select(&:str_type?).map(&:value).join
+          end
+        end
+
         def message(node, prefer)
           format(MSG, prefer: prefer, method_name: node.method_name)
         end
 
         def detect_unnecessary_fields(node)
           return unless node.first_argument&.str_type?
+          return if node.first_argument.heredoc?
 
           string = node.first_argument.value
           arguments = node.arguments[1..]
@@ -245,6 +266,14 @@ module RuboCop
         def argument_value(argument)
           argument = argument.children.first if argument.begin_type?
 
+          # `nil` formats to an empty string (`format('%s', nil) == ''`), not the
+          # literal `'nil'` that `argument.source` would return.
+          return if argument.nil_type?
+
+          typed_argument_value(argument)
+        end
+
+        def typed_argument_value(argument)
           if argument.dsym_type?
             dsym_value(argument)
           elsif argument.hash_type?

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

@@ -48,8 +48,13 @@ module RuboCop
         def need_heredoc_delimiter_quotes?(node)
           heredoc_delimiter = node.source.delete(heredoc_type(node))
           return true unless heredoc_delimiter.start_with?("'", '"')
+          return true if node.loc.heredoc_end.source.strip.match?(/\W/)
 
-          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+          # A double-quoted delimiter interpolates exactly like an unquoted one,
+          # so its quotes are always redundant. A single-quoted delimiter is
+          # required when the body contains interpolation or escapes that would
+          # otherwise be evaluated.
+          heredoc_delimiter.start_with?("'") &&
             node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
         end
       end

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

@@ -165,11 +165,11 @@ module RuboCop
         end
 
         def inspect_end_of_ruby_code_line_continuation
-          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          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)
 
-          last_column = last_line.length
-          line_continuation_range = range_between(last_column - 1, last_column)
+          line_continuation_range = trailing_line_continuation_range(last_line_number)
 
           add_offense(line_continuation_range) do |corrector|
             corrector.remove_trailing(line_continuation_range, 1)
@@ -182,6 +182,14 @@ module RuboCop
           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).
+        def trailing_line_continuation_range(line_number)
+          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

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

@@ -65,7 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
-          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
+          return true if requires_escape_to_avoid_interpolation?(node, index, char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -97,10 +97,14 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+        def requires_escape_to_avoid_interpolation?(node, index, escaped_char)
           # Preserve escapes after '#' that would otherwise trigger interpolation:
-          # '#@ivar', '#@@cvar', and '#$gvar'.
-          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+          # '#@ivar', '#@@cvar', and '#$gvar'. `index` is relative to the regexp
+          # contents, so index into those rather than `node.source` (which also
+          # includes the opening delimiter, e.g. `%r{`).
+          return false unless index.positive? && INTERPOLATION_SIGILS.include?(escaped_char)
+
+          contents_range(node).source[index - 1] == '#'
         end
 
         def each_escape(node)

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

@@ -100,6 +100,15 @@ module RuboCop
           add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
         end
 
+        # Register the exception variable of `rescue => e` so that `self.e` in the
+        # body is not treated as redundant (it disambiguates the local variable).
+        def on_resbody(node)
+          exception_variable = node.exception_variable
+          return unless exception_variable&.lvasgn_type?
+
+          @local_variables_scopes[node] << exception_variable.name
+        end
+
         def on_in_pattern(node)
           add_match_var_scopes(node)
         end

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

@@ -100,12 +100,31 @@ module RuboCop
         end
 
         def range(redundant_keyword_init)
-          if redundant_keyword_init.parent.left_siblings.last.is_a?(AST::Node)
-            beginning_of_range = redundant_keyword_init.parent.left_siblings.last.source_range.end
+          if redundant_keyword_init.parent.pairs.all? { |pair| keyword_init?(pair) }
+            # The hash holds only `keyword_init` pairs, so it is emptied; anchor the
+            # removal before the hash to also drop the comma that precedes it.
+            range_emptying_hash(redundant_keyword_init)
+          else
+            # Other pairs remain, so just drop this pair and one adjacent comma.
+            range_within_hash(redundant_keyword_init)
+          end
+        end
+
+        def range_within_hash(pair)
+          if (left = pair.left_sibling)
+            left.source_range.end.join(pair.source_range.end)
+          elsif (right = pair.right_sibling)
+            pair.source_range.begin.join(right.source_range.begin)
+          else
+            pair.source_range
+          end
+        end
 
-            beginning_of_range.join(redundant_keyword_init.source_range.end)
+        def range_emptying_hash(pair)
+          if (preceding = pair.parent.left_sibling).is_a?(AST::Node)
+            preceding.source_range.end.join(pair.source_range.end)
           else
-            redundant_keyword_init
+            pair.source_range
           end
         end
       end

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

@@ -128,7 +128,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             if after_expression
-              corrector.replace(range, "\n")
+              replace_semicolon_with_line_break(corrector, range)
             else
               # Prevents becoming one range instance with subsequent line when endless range
               # without parentheses.
@@ -148,6 +148,21 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+        def replace_semicolon_with_line_break(corrector, range)
+          # Replacing the semicolon with a newline would move the rest of the
+          # line into the body of a heredoc opened earlier on that line.
+          return if heredoc_opened_before_semicolon?(range)
+
+          corrector.replace(range, "\n")
+        end
+
+        def heredoc_opened_before_semicolon?(semicolon_range)
+          processed_source.ast.each_descendant(:any_str).select(&:heredoc?).any? do |heredoc|
+            heredoc.first_line == semicolon_range.line &&
+              heredoc.source_range.end_pos <= semicolon_range.begin_pos
+          end
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
           exprs_lines = exprs.map(&:last_line)
@@ -155,10 +170,10 @@ module RuboCop
         end
 
         def find_semicolon_positions(line)
-          # Scan for all the semicolons on the line
-          semicolons = processed_source[line - 1].enum_for(:scan, ';')
-          semicolons.each do
-            yield Regexp.last_match.begin(0)
+          # Scan for all the semicolon tokens on the line. Iterating tokens rather
+          # than the raw source skips `;` characters inside string/regexp literals.
+          processed_source.tokens.each do |token|
+            yield token.column if token.line == line && token.semicolon?
           end
         end
 

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

@@ -44,11 +44,12 @@ module RuboCop
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
 
-            node_body = node.body
-
-            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+            if (heredoc = trailing_heredoc(node.body))
+              # The heredoc body extends past the `end` on the source, so the
+              # `end` has to be moved after it rather than before, which would
+              # otherwise move it into the heredoc body and break the syntax.
               corrector.remove(node.loc.end)
-              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+              corrector.insert_after(heredoc.loc.heredoc_end, "\nend")
             else
               corrector.insert_before(node.loc.end, "\n")
             end
@@ -60,6 +61,18 @@ module RuboCop
 
         private
 
+        # Returns the heredoc opened on the block's line whose body extends the
+        # furthest down, whether it is the block body itself or nested within it.
+        def trailing_heredoc(node_body)
+          return unless node_body
+
+          heredocs = [node_body, *node_body.each_descendant].select do |node|
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          heredocs.max_by { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
         def do_line(node)
           if node.type?(:numblock, :itblock) ||
              node.arguments.children.empty? || node.send_node.lambda_literal?

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

@@ -41,6 +41,7 @@ module RuboCop
 
         def on_pair(node)
           return unless string_hash_key?(node)
+          return if node.key.heredoc?
 
           key_content = node.key.str_content
           return unless key_content.valid_encoding?

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

@@ -41,7 +41,9 @@ module RuboCop
           return unless struct_constructor?(node.parent_class)
 
           add_offense(node.parent_class) do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.remove(
+              range_with_surrounding_space(node.loc.keyword, side: :right, newlines: false)
+            )
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)