rubocop 1.75.2 → 1.76.0

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

@@ -16,16 +16,16 @@ module RuboCop
       #
       # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
       #
-      # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
-      # replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
-      # by setting `UseAnonymousForwarding: false`.
+      # This cop also identifies places where `+use_args(*args)+`/`+use_kwargs(**kwargs)+` can be
+      # replaced by `+use_args(*)+`/`+use_kwargs(**)+`; if desired, this functionality can be
+      # disabled by setting `UseAnonymousForwarding: false`.
       #
       # And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`,
       # and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names
       # that are sufficient for anonymizing meaningless naming.
       #
       # Meaningless names that are commonly used can be anonymized by default:
-      # e.g., `*args`, `**options`, `&block`, and so on.
+      # e.g., `+*args+`, `+**options+`, `&block`, and so on.
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
@@ -146,7 +146,7 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
-        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
+        ADDITIONAL_ARG_TYPES = %i[lvar arg optarg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -479,6 +479,9 @@ module RuboCop
           end
 
           def ruby_32_only_anonymous_forwarding?
+            # A block argument and an anonymous block argument are never passed together.
+            return false if @send_node.each_ancestor(:any_block).any?
+
             def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
           end
 

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

@@ -131,21 +131,27 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
+                               body.loc.name.end_pos
+                             else
+                               body.loc.end.begin_pos - leading_spaces(body).size
+                             end
           adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
           range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def unindent(corrector, node)
           return unless node.body.children.last
 
           last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if leading_spaces(node).size == last_child_leading_spaces.size
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
 
-          column_delta = configured_indentation_width - last_child_leading_spaces.size
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -155,6 +161,16 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
+        def spaces_size(spaces_string)
+          mapping = { "\t" => tab_indentation_width }
+          spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+            configured_indentation_width
+        end
+
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 

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

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
         end
       end
     end

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

@@ -58,7 +58,7 @@ module RuboCop
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
         SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
-        METHOD_DEFINITION = /\A\s*def\s/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
 
         STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
 
@@ -102,7 +102,7 @@ module RuboCop
           case line
           when SUBCLASS_DEFINITION
             comment.text.start_with?(/#\[.+\]/)
-          when METHOD_DEFINITION
+          when METHOD_OR_END_DEFINITIONS
             comment.text.start_with?('#:')
           else
             false

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

@@ -9,6 +9,9 @@ module RuboCop
       # although the difference generally isn't observable. If you require maximum
       # performance, consider using logical comparison.
       #
+      # @safety
+      #   This cop is unsafe because the receiver may not respond to `between?`.
+      #
       # @example
       #
       #   # bad
@@ -61,8 +64,8 @@ module RuboCop
 
         def register_offense(node, min_and_value, max_and_value)
           value = (min_and_value & max_and_value).first
-          min = min_and_value.find { _1 != value }
-          max = max_and_value.find { _1 != value }
+          min = min_and_value.find { _1 != value } || value
+          max = max_and_value.find { _1 != value } || value
 
           prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|

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

@@ -314,6 +314,7 @@ module RuboCop
 
         def assignment_node(node)
           assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
@@ -436,7 +437,7 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
@@ -446,13 +447,19 @@ module RuboCop
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            next unless loc
-
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
-        # rubocop:enable Metrics/AbcSize
 
         def white_space_range(node, column)
           expression = node.source_range
@@ -598,6 +605,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -25,8 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -38,19 +39,31 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          return true if node.single_line? && !node.endless?
+
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for empty strings being assigned inside string interpolation.
+      #
+      # Empty strings are a meaningless outcome inside of string interpolation, so we remove them.
+      # Alternatively, when configured to do so, we prioritise using empty strings.
+      #
+      # While this cop would also apply to variables that are only going to be used as strings,
+      # RuboCop can't detect that, so we only check inside of string interpolation.
+      #
+      # @example EnforcedStyle: trailing_conditional (default)
+      #   # bad
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # good
+      #   "#{'foo' if condition}"
+      #
+      #   # bad
+      #   "#{condition ? '' : 'foo'}"
+      #
+      #   # good
+      #   "#{'foo' unless condition}"
+      #
+      # @example EnforcedStyle: ternary
+      #   # bad
+      #   "#{'foo' if condition}"
+      #
+      #   # good
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # bad
+      #   "#{'foo' unless condition}"
+      #
+      #   # good
+      #   "#{condition ? '' : 'foo'}"
+      #
+      class EmptyStringInsideInterpolation < Base
+        include ConfigurableEnforcedStyle
+        include Interpolation
+        extend AutoCorrector
+
+        MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
+        MSG_TERNARY = 'Do not return empty strings in string interpolation.'
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def on_interpolation(node)
+          node.each_child_node(:if) do |child_node|
+            if style == :trailing_conditional
+              if empty_if_outcome?(child_node)
+                ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+              end
+
+              if empty_else_outcome?(child_node)
+                ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+              end
+            elsif style == :ternary
+              next unless child_node.modifier_form?
+
+              ternary_component = if child_node.unless?
+                                    "'' : #{child_node.if_branch.source}"
+                                  else
+                                    "#{child_node.if_branch.source} : ''"
+                                  end
+
+              add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+                corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        private
+
+        def empty_if_outcome?(node)
+          empty_branch_outcome?(node.if_branch)
+        end
+
+        def empty_else_outcome?(node)
+          empty_branch_outcome?(node.else_branch)
+        end
+
+        def empty_branch_outcome?(branch)
+          return false unless branch
+
+          branch.nil_type? || (branch.str_type? && branch.value.empty?)
+        end
+
+        def ternary_style_autocorrect(node, outcome, condition)
+          add_offense(node, message: MSG_TERNARY) do |corrector|
+            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
-      # and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
-      # and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
+      # and `module_eval`) are given filename and line number values (`+__FILE__+`
+      # and `+__LINE__+`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
+      # The cop also checks that the line number given relative to `+__LINE__+` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number

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

@@ -40,7 +40,6 @@ module RuboCop
       class HashFetchChain < Base
         extend AutoCorrector
         extend TargetRubyVersion
-        include IgnoredNode
 
         MSG = 'Use `%<replacement>s` instead.'
         RESTRICT_ON_SEND = %i[fetch].freeze

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `\_.each_with_object({}) {...}`,
-      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       # It should only be enabled on Ruby version 2.5 or newer.

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `\_.each_with_object({}) {...}`,
-      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #

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

@@ -189,7 +189,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -197,7 +197,7 @@ module RuboCop
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
-              next if node.if_type? && node.ternary?
+              next if node.if_type? && (node.ternary? || node.then?)
 
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
@@ -213,7 +213,7 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def correct_assignment(corrector, node, expression, insert_position)
           if insert_position == :after_condition

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

@@ -23,6 +23,17 @@ module RuboCop
       # end
       # ----
       #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -77,10 +88,14 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
+          return if endless_method?(node.body)
+
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
                     pattern_matching_nodes(condition).any?
+
           return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
@@ -90,9 +105,14 @@ module RuboCop
             ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
         def defined_nodes(condition)
           if condition.defined_type?
             [condition]
@@ -112,12 +132,10 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.type?(:match_pattern, :match_pattern_p)
+          if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select do |node|
-              node.type?(:match_pattern, :match_pattern_p)
-            end
+            condition.each_descendant.select(&:any_match_pattern_type?)
           end
         end
 

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

@@ -28,19 +28,16 @@ module RuboCop
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
           add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
-            keyword = node.if? ? 'if' : 'unless'
-
-            corrector.replace(node, <<~RUBY.chop)
-              #{keyword} #{node.condition.source}
-              #{node.if_branch.source}
-              end
-            RUBY
+            corrector.wrap(node.if_branch, "#{node.keyword} #{node.condition.source}\n", "\nend")
+            corrector.remove(node.if_branch.source_range.end.join(node.condition.source_range.end))
           end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -10,7 +10,7 @@ module RuboCop
       # `nonzero?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
-      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # This cop targets only ``if``s with a single `elsif` or `else` branch. The following
       # code will be allowed, because it has two `elsif` branches:
       #
       # [source,ruby]

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

@@ -5,15 +5,28 @@ module RuboCop
     module Style
       # Checks for blocks with one argument where `it` block parameter can be used.
       #
-      # It provides three `EnforcedStyle` options:
+      # It provides four `EnforcedStyle` options:
       #
-      # 1. `only_numbered_parameters` (default) ... Detects only numbered block parameters.
-      # 2. `always` ... Always uses the `it` block parameter.
-      # 3. `disallow` ... Disallows the `it` block parameter.
+      # 1. `allow_single_line` (default) ... Always uses the `it` block parameter in a single line.
+      # 2. `only_numbered_parameters` ... Detects only numbered block parameters.
+      # 3. `always` ... Always uses the `it` block parameter.
+      # 4. `disallow` ... Disallows the `it` block parameter.
       #
-      # A single numbered parameter is detected when `only_numbered_parameters` or `always`.
+      # A single numbered parameter is detected when `allow_single_line`,
+      # `only_numbered_parameters`, or `always`.
       #
-      # @example EnforcedStyle: only_numbered_parameters (default)
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   block do
+      #     do_something(it)
+      #   end
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: only_numbered_parameters
       #   # bad
       #   block { do_something(_1) }
       #
@@ -42,8 +55,9 @@ module RuboCop
         extend TargetRubyVersion
         extend AutoCorrector
 
-        MSG_USE_IT_BLOCK_PARAMETER = 'Use `it` block parameter.'
-        MSG_AVOID_IT_BLOCK_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_USE_IT_PARAMETER = 'Use `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
 
         minimum_target_ruby_version 3.4
 
@@ -57,7 +71,7 @@ module RuboCop
           variables = find_block_variables(node, node.first_argument.source)
 
           variables.each do |variable|
-            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
             end
@@ -71,19 +85,24 @@ module RuboCop
           variables = find_block_variables(node, '_1')
 
           variables.each do |variable|
-            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.replace(variable, 'it')
             end
           end
         end
 
         def on_itblock(node)
-          return unless style == :disallow
+          case style
+          when :allow_single_line
+            return if node.single_line?
 
-          variables = find_block_variables(node, 'it')
+            add_offense(node, message: MSG_AVOID_IT_PARAMETER_MULTI_LINE)
+          when :disallow
+            variables = find_block_variables(node, 'it')
 
-          variables.each do |variable|
-            add_offense(variable, message: MSG_AVOID_IT_BLOCK_PARAMETER)
+            variables.each do |variable|
+              add_offense(variable, message: MSG_AVOID_IT_PARAMETER)
+            end
           end
         end
 

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

@@ -54,9 +54,14 @@ module RuboCop
 
         def prefer(node)
           receiver = node.receiver.source
-          arguments = node.arguments.map(&:source).join(', ')
           dot = node.loc.dot.source
-          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+          call_arguments = if node.arguments.empty?
+                             ''
+                           else
+                             arguments = node.arguments.map(&:source).join(', ')
+                             "(#{arguments})"
+                           end
+          method = explicit_style? ? "call#{call_arguments}" : "(#{arguments})"
 
           "#{receiver}#{dot}#{method}"
         end

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

@@ -212,9 +212,11 @@ module RuboCop
         end
 
         def correct_push_node(corrector, push_node)
+          arg_node = push_node.first_argument
           range = push_node.source_range
-          arg_range = push_node.first_argument.source_range
+          arg_range = arg_node.source_range
 
+          corrector.wrap(arg_node, '{ ', ' }') if arg_node.hash_type? && !arg_node.braces?
           corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
           corrector.remove(range_between(arg_range.end_pos, range.end_pos))
         end