rubocop 1.57.2 → 1.58.0

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -17,24 +17,24 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #

data/lib/rubocop/cop/lint/debugger.rb

@@ -66,6 +66,7 @@ module RuboCop
       #   end
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
+        BLOCK_TYPES = %i[block numblock kwbegin].freeze
 
         def on_send(node)
           return if !debugger_method?(node) || assumed_usage_context?(node)
@@ -98,7 +99,7 @@ module RuboCop
           return true if assumed_argument?(node)
 
           node.each_ancestor.none? do |ancestor|
-            ancestor.block_type? || ancestor.numblock_type? || ancestor.lambda_or_proc?
+            BLOCK_TYPES.include?(ancestor.type) || ancestor.lambda_or_proc?
           end
         end
 

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -253,7 +253,7 @@ module RuboCop
           # Assume that if a method definition is inside any block call which
           # we can't identify, it could be a DSL
           node.each_ancestor(:block).any? do |ancestor|
-            ancestor.method_name != :class_eval && !ancestor.class_constructor?
+            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
           end
         end
 

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -106,7 +106,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          str_arg = node.arguments[0].source
+          str_arg = node.first_argument.source
 
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
@@ -121,11 +121,11 @@ module RuboCop
         end
 
         def build_kwargs(node)
-          return [nil, nil] unless node.arguments.last.hash_type?
+          return [nil, nil] unless node.last_argument.hash_type?
 
           trim_mode_arg, eoutvar_arg = nil
 
-          node.arguments.last.pairs.each do |pair|
+          node.last_argument.pairs.each do |pair|
             case pair.key.source
             when 'trim_mode'
               trim_mode_arg = "trim_mode: #{pair.value.source}"

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -18,6 +18,10 @@ module RuboCop
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
+      #  # good - comparing against zero
+      #   x == 0.0
+      #   x != 0.0
+      #
       #   # good
       #   (x - 0.1).abs < Float::EPSILON
       #
@@ -39,6 +43,8 @@ module RuboCop
 
         def on_send(node)
           lhs, _method, rhs = *node
+          return if literal_zero?(lhs) || literal_zero?(rhs)
+
           add_offense(node) if float?(lhs) || float?(rhs)
         end
 
@@ -59,6 +65,10 @@ module RuboCop
           end
         end
 
+        def literal_zero?(node)
+          node&.numeric_type? && node.value.zero?
+        end
+
         # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?

data/lib/rubocop/cop/lint/literal_assignment_in_condition.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.to_a.last
+            next unless rhs.respond_to?(:literal?) && rhs.literal?
+
+            range = asgn_node.loc.operator.join(rhs.source_range.end)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if AST::Node::EQUALS_ASSIGNMENTS.include?(node.type)
+
+          node.each_child_node { |child| traverse_node(child, &block) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -94,7 +94,7 @@ module RuboCop
           parent_node = node.parent
 
           add_offense(parent_node) do |corrector|
-            if parent_node.arguments.last&.block_pass_type?
+            if parent_node.last_argument&.block_pass_type?
               correct_block_pass(corrector, parent_node)
             else
               correct_block(corrector, parent_node)
@@ -116,7 +116,7 @@ module RuboCop
 
         def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            block_arg = node.arguments.last
+            block_arg = node.last_argument
 
             corrector.remove(last_arg_range(node))
             corrector.insert_after(node, ".sort.each(#{block_arg.source})")
@@ -130,9 +130,7 @@ module RuboCop
         # @return [Parser::Source::Range]
         #
         def last_arg_range(node)
-          node.arguments.last.source_range.with(
-            begin_pos: node.arguments[-2].source_range.end_pos
-          )
+          node.last_argument.source_range.with(begin_pos: node.arguments[-2].source_range.end_pos)
         end
 
         def unsorted_dir_loop?(node)

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -50,6 +50,22 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      #   # bad - for `nil`s conversion methods return default values for the type
+      #   foo&.to_h || {}
+      #   foo&.to_h { |k, v| [k, v] } || {}
+      #   foo&.to_a || []
+      #   foo&.to_i || 0
+      #   foo&.to_f || 0.0
+      #   foo&.to_s || ''
+      #
+      #   # good
+      #   foo.to_h
+      #   foo.to_h { |k, v| [k, v] }
+      #   foo.to_a
+      #   foo.to_i
+      #   foo.to_f
+      #   foo.to_s
+      #
       # @example AllowedMethods: [nil_safe_method]
       #   # bad
       #   do_something if attrs&.nil_safe_method(:[])
@@ -64,6 +80,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected.'
+        MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
@@ -74,6 +91,18 @@ module RuboCop
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN
 
+        # @!method conversion_with_default?(node)
+        def_node_matcher :conversion_with_default?, <<~PATTERN
+          {
+            (or $(csend _ :to_h) (hash))
+            (or (block $(csend _ :to_h) ...) (hash))
+            (or $(csend _ :to_a) (array))
+            (or $(csend _ :to_i) (int 0))
+            (or $(csend _ :to_f) (float 0.0))
+            (or $(csend _ :to_s) (str empty?))
+          }
+        PATTERN
+
         # rubocop:disable Metrics/AbcSize
         def on_csend(node)
           unless node.receiver.const_type? && !node.receiver.source.match?(SNAKE_CASE)
@@ -84,6 +113,20 @@ module RuboCop
           range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
           add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+
+        def on_or(node)
+          conversion_with_default?(node) do |send_node|
+            range = range_between(send_node.loc.dot.begin_pos, node.source_range.end_pos)
+
+            add_offense(range, message: MSG_LITERAL) do |corrector|
+              corrector.replace(send_node.loc.dot, '.')
+
+              range_with_default = range_between(node.lhs.source_range.end.begin_pos,
+                                                 node.source_range.end.end_pos)
+              corrector.remove(range_with_default)
+            end
+          end
+        end
         # rubocop:enable Metrics/AbcSize
 
         private

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -45,10 +45,9 @@ module RuboCop
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
-            location =
-              Parser::Source::Range.new(node.source_range.source_buffer,
-                                        safe_nav.source_range.end_pos,
-                                        node.source_range.end_pos)
+            begin_range = node.loc.dot || safe_nav.source_range.end
+            location = begin_range.join(node.source_range.end)
+
             add_offense(location) do |corrector|
               autocorrect(corrector, offense_range: location, send_node: node)
             end

data/lib/rubocop/cop/lint/self_assignment.rb

@@ -10,11 +10,18 @@ module RuboCop
       #   foo = foo
       #   foo, bar = foo, bar
       #   Foo = Foo
+      #   hash['foo'] = hash['foo']
+      #   obj.attr = obj.attr
       #
       #   # good
       #   foo = bar
       #   foo, bar = bar, foo
       #   Foo = Bar
+      #   hash['foo'] = hash['bar']
+      #   obj.attr = obj.attr2
+      #
+      #   # good (method calls possibly can return different results)
+      #   hash[foo] = hash[foo]
       #
       class SelfAssignment < Base
         MSG = 'Self-assignment detected.'
@@ -26,6 +33,15 @@ module RuboCop
           gvasgn: :gvar
         }.freeze
 
+        def on_send(node)
+          if node.method?(:[]=)
+            handle_key_assignment(node) if node.arguments.size == 2
+          elsif node.assignment_method?
+            handle_attribute_assignment(node) if node.arguments.size == 1
+          end
+        end
+        alias on_csend on_send
+
         def on_lvasgn(node)
           lhs, rhs = *node
           return unless rhs
@@ -72,6 +88,27 @@ module RuboCop
           rhs.type == ASSIGNMENT_TYPE_TO_RHS_TYPE[lhs.type] &&
             rhs.children.first == lhs.children.first
         end
+
+        def handle_key_assignment(node)
+          value_node = node.arguments[1]
+
+          if value_node.send_type? && value_node.method?(:[]) &&
+             node.receiver == value_node.receiver &&
+             !node.first_argument.call_type? &&
+             node.first_argument == value_node.first_argument
+            add_offense(node)
+          end
+        end
+
+        def handle_attribute_assignment(node)
+          first_argument = node.first_argument
+
+          if first_argument.call_type? &&
+             node.receiver == first_argument.receiver &&
+             first_argument.method_name.to_s == node.method_name.to_s.delete_suffix('=')
+            add_offense(node)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -19,6 +19,7 @@ module RuboCop
       #   'underscored_string'.to_sym
       #   :'underscored_symbol'
       #   'hyphenated-string'.to_sym
+      #   "string_#{interpolation}".to_sym
       #
       #   # good
       #   :string
@@ -26,6 +27,7 @@ module RuboCop
       #   :underscored_string
       #   :underscored_symbol
       #   :'hyphenated-string'
+      #   :"string_#{interpolation}"
       #
       # @example EnforcedStyle: strict (default)
       #
@@ -75,9 +77,12 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
-          return unless node.receiver.str_type? || node.receiver.sym_type?
 
-          register_offense(node, correction: node.receiver.value.to_sym.inspect)
+          if node.receiver.str_type? || node.receiver.sym_type?
+            register_offense(node, correction: node.receiver.value.to_sym.inspect)
+          elsif node.receiver.dstr_type?
+            register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
+          end
         end
 
         def on_sym(node)

data/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb

@@ -34,7 +34,7 @@ module RuboCop
         MSG = 'Avoid leaving a trailing comma in attribute declarations.'
 
         def on_send(node)
-          return unless node.attribute_accessor? && node.arguments.last.def_type?
+          return unless node.attribute_accessor? && node.last_argument.def_type?
 
           trailing_comma = trailing_comma_range(node)
 

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -256,7 +256,7 @@ module RuboCop
 
         def any_method_definition?(child)
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
-            matcher_name = "#{m}_method?".to_sym
+            matcher_name = :"#{m}_method?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
                 {def (send nil? :#{m} ...)}
@@ -279,7 +279,7 @@ module RuboCop
 
         def any_context_creating_methods?(child)
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
-            matcher_name = "#{m}_block?".to_sym
+            matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
                 ({block numblock} (send {nil? const} {:#{m}} ...) ...)

data/lib/rubocop/cop/lint/void.rb

@@ -144,7 +144,7 @@ module RuboCop
         end
 
         def check_literal(node)
-          return if !node.literal? || node.xstr_type? || node.range_type?
+          return if !entirely_literal?(node) || node.xstr_type? || node.range_type?
 
           add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
             autocorrect_void_expression(corrector, node)
@@ -217,6 +217,19 @@ module RuboCop
                       end
           corrector.replace(send_node.loc.selector, suggestion)
         end
+
+        def entirely_literal?(node)
+          case node.type
+          when :array
+            node.each_value.all? { |value| entirely_literal?(value) }
+          when :hash
+            return false unless node.each_key.all? { |key| entirely_literal?(key) }
+
+            node.each_value.all? { |value| entirely_literal?(value) }
+          else
+            node.literal?
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -218,7 +218,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.arguments.last.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.def_type?
 
         !node.single_line?
       end

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -79,7 +79,7 @@ module RuboCop
       end
 
       def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+        aligned_identical?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_words?(range, line)

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
+        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -48,13 +48,13 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator]
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
         end
 
         def on_def(node)
           return if node.arguments.empty?
 
-          last_argument = node.arguments.last
+          last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
           register_offense(last_argument, node)

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -203,7 +203,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
-          arg = node.arguments.first
+          arg = node.first_argument
           return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)

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

@@ -168,12 +168,12 @@ module RuboCop
 
         def find_corresponding_def_node(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.arguments.first.value
+            method_name = node.first_argument.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end
           else
-            node.arguments.first
+            node.first_argument
           end
         end
 

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

@@ -166,7 +166,7 @@ module RuboCop
               *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
             ]
-            if arg == node.arguments.first
+            if arg == node.first_argument
               lines
             else
               indent = ' ' * node.loc.column

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

@@ -12,7 +12,16 @@ module RuboCop
       #
       # 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.
+      # 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.
+      #
+      # Names not on this list are likely to be meaningful and are allowed by default.
       #
       # @example
       #   # bad
@@ -72,6 +81,38 @@ module RuboCop
       #     bar(**kwargs)
       #   end
       #
+      # @example RedundantRestArgumentNames: ['args', 'arguments'] (default)
+      #   # bad
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      #   # good
+      #   def foo(*)
+      #     bar(*)
+      #   end
+      #
+      # @example RedundantKeywordRestArgumentNames: ['kwargs', 'options', 'opts'] (default)
+      #   # bad
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
+      #   # good
+      #   def foo(**)
+      #     bar(**)
+      #   end
+      #
+      # @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default)
+      #   # bad
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
       class ArgumentsForwarding < Base
         include RangeHelp
         extend AutoCorrector
@@ -86,16 +127,19 @@ module RuboCop
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
         KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
 
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
+
         def on_def(node)
           return unless node.body
 
-          forwardable_args = extract_forwardable_args(node.arguments)
+          restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
+          forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
+          send_nodes = node.each_descendant(:send).to_a
 
           send_classifications = classify_send_nodes(
-            node,
-            node.each_descendant(:send).to_a,
-            non_splat_or_block_pass_lvar_references(node.body),
-            forwardable_args
+            node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
           )
 
           return if send_classifications.empty?
@@ -115,6 +159,14 @@ module RuboCop
           [args.find(&:restarg_type?), args.find(&:kwrestarg_type?), args.find(&:blockarg_type?)]
         end
 
+        def redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
+          restarg_node = redundant_named_arg(restarg, 'RedundantRestArgumentNames', '*')
+          kwrestarg_node = redundant_named_arg(kwrestarg, 'RedundantKeywordRestArgumentNames', '**')
+          blockarg_node = redundant_named_arg(blockarg, 'RedundantBlockArgumentNames', '&')
+
+          [restarg_node, kwrestarg_node, blockarg_node]
+        end
+
         def only_forwards_all?(send_classifications)
           send_classifications.all? { |_, c, _, _| c == :all }
         end
@@ -188,6 +240,16 @@ module RuboCop
           [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
         end
 
+        def redundant_named_arg(arg, config_name, keyword)
+          return nil unless arg
+
+          redundant_arg_names = cop_config.fetch(config_name, []).map do |redundant_arg_name|
+            "#{keyword}#{redundant_arg_name}"
+          end << keyword
+
+          redundant_arg_names.include?(arg.source) ? arg : nil
+        end
+
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
           add_offense(rest_arg_or_splat, message: ARGS_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector)