rubocop 1.75.1 → 1.77.0

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

@@ -23,6 +23,14 @@ module RuboCop
       #   # good (method calls possibly can return different results)
       #   hash[foo] = hash[foo]
       #
+      # @example AllowRBSInlineAnnotation:true
+      #   # good
+      #   foo = foo #: Integer
+      #   foo, bar = foo, bar #: Integer
+      #   Foo = Foo #: Integer
+      #   hash['foo'] = hash['foo'] #: Integer
+      #   obj.attr = obj.attr #: Integer
+      #
       class SelfAssignment < Base
         MSG = 'Self-assignment detected.'
 
@@ -34,6 +42,8 @@ module RuboCop
         }.freeze
 
         def on_send(node)
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.receiver)
+
           if node.method?(:[]=)
             handle_key_assignment(node) if node.arguments.size == 2
           elsif node.assignment_method?
@@ -44,6 +54,7 @@ module RuboCop
 
         def on_lvasgn(node)
           return unless node.rhs
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.rhs)
 
           rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
 
@@ -55,16 +66,22 @@ module RuboCop
 
         def on_casgn(node)
           return unless node.rhs&.const_type?
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.rhs)
 
           add_offense(node) if node.namespace == node.rhs.namespace &&
                                node.short_name == node.rhs.short_name
         end
 
         def on_masgn(node)
+          first_lhs = node.lhs.assignments.first
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(first_lhs)
+
           add_offense(node) if multiple_self_assignment?(node)
         end
 
         def on_or_asgn(node)
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.lhs)
+
           add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
         end
         alias on_and_asgn on_or_asgn
@@ -108,6 +125,14 @@ module RuboCop
             add_offense(node)
           end
         end
+
+        def rbs_inline_annotation?(node)
+          processed_source.ast_with_comments[node].any? { |comment| comment.text.start_with?('#:') }
+        end
+
+        def allow_rbs_inline_annotation?
+          cop_config['AllowRBSInlineAnnotation']
+        end
       end
     end
   end

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

@@ -8,6 +8,11 @@ module RuboCop
       # given by `ruby -cw` prior to Ruby 2.6:
       # "shadowing outer local variable - foo".
       #
+      # The cop is now disabled by default to match the upstream Ruby behavior.
+      # It's useful, however, if you'd like to avoid shadowing variables from outer
+      # scopes, which some people consider an anti-pattern that makes it harder
+      # to keep track of what's going on in a program.
+      #
       # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
       # because `Ractor` should not access outer variables.
       # eg. following style is encouraged:

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

@@ -116,7 +116,7 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :any_block).first
+          ancestor = node.each_ancestor(:kwbegin, :any_def, :any_block).first
           return false unless ancestor
 
           end_line = ancestor.loc.end&.line || ancestor.loc.last_line

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

@@ -45,7 +45,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|

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

@@ -40,7 +40,7 @@ module RuboCop
         # top-level return node's ancestors should not be of block, def, or
         # defs type.
         def top_level_return?(return_node)
-          return_node.each_ancestor(:block, :def, :defs).none?
+          return_node.each_ancestor(:block, :any_def).none?
         end
       end
     end

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

@@ -4,10 +4,10 @@ module RuboCop
   module Cop
     module Lint
       # Checks for redundant access modifiers, including those with no
-      # code, those which are repeated, and leading `public` modifiers in a
-      # class or module body. Conditionally-defined methods are considered as
-      # always being defined, and thus access modifiers guarding such methods
-      # are not redundant.
+      # code, those which are repeated, those which are on top-level, and
+      # leading `public` modifiers in a class or module body.
+      # Conditionally-defined methods are considered as always being defined,
+      # and thus access modifiers guarding such methods are not redundant.
       #
       # This cop has `ContextCreatingMethods` option. The default setting value
       # is an empty array that means no method is specified.
@@ -58,6 +58,12 @@ module RuboCop
       #     private # this is redundant (no following methods are defined)
       #   end
       #
+      #   # bad
+      #   private # this is useless (access modifiers have no effect on top-level)
+      #
+      #   def method
+      #   end
+      #
       #   # good
       #   class Foo
       #     private # this is not redundant (a method is defined)
@@ -145,6 +151,17 @@ module RuboCop
         alias on_numblock on_block
         alias on_itblock on_block
 
+        def on_begin(node)
+          return if node.parent
+
+          node.child_nodes.each do |child|
+            next unless child.send_type? && access_modifier?(child)
+
+            # This call always registers an offense for access modifier `child.method_name`
+            check_send_node(child, child.method_name, true)
+          end
+        end
+
         private
 
         def autocorrect(corrector, node)
@@ -257,6 +274,10 @@ module RuboCop
 
         def any_method_definition?(child)
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            # Some users still have `"included"` in their `MethodCreatingMethods` configurations,
+            # so to prevent Ruby method redefinition warnings let's just skip this value.
+            next if m == 'included'
+
             matcher_name = :"#{m}_method?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
@@ -279,7 +300,11 @@ module RuboCop
         end
 
         def any_context_creating_methods?(child)
+          # Some users still have `"included"` in their `ContextCreatingMethods` configurations,
+          # so to prevent Ruby method redefinition warnings let's just skip this value.
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            next if m == 'included'
+
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN

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

@@ -104,6 +104,8 @@ module RuboCop
         end
 
         def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
           node.respond_to?(:expression) && node.expression&.lvasgn_type?
         end
 

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for usage of method `fetch` or `Array.new` with default value argument
+      # and block. In such cases, block will always be used as default value.
+      #
+      # This cop emulates Ruby warning "block supersedes default value argument" which
+      # applies to `Array.new`, `Array#fetch`, `Hash#fetch`, `ENV.fetch` and
+      # `Thread#fetch`.
+      #
+      # A `fetch` call without a receiver is considered a custom method and does not register
+      # an offense.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver could have nonstandard implementation
+      #   of `fetch`, or be a class other than the one listed above.
+      #
+      #   It is also unsafe because default value argument could have side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   def x(a) = puts "side effect"
+      #   Array.new(5, x(1)) { 2 }
+      #   ----
+      #
+      #   so removing it would change behavior.
+      #
+      # @example
+      #   # bad
+      #   x.fetch(key, default_value) { block_value }
+      #   Array.new(size, default_value) { block_value }
+      #
+      #   # good
+      #   x.fetch(key) { block_value }
+      #   Array.new(size) { block_value }
+      #
+      #   # also good - in case default value argument is desired instead
+      #   x.fetch(key, default_value)
+      #   Array.new(size, default_value)
+      #
+      #   # good - keyword arguments aren't registered as offenses
+      #   x.fetch(key, keyword: :arg) { block_value }
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class UselessDefaultValueArgument < Base
+        include AllowedReceivers
+        extend AutoCorrector
+
+        MSG = 'Block supersedes default value argument.'
+
+        RESTRICT_ON_SEND = %i[fetch new].freeze
+
+        # @!method default_value_argument_and_block(node)
+        def_node_matcher :default_value_argument_and_block, <<~PATTERN
+          (any_block
+            {
+              (call !nil? :fetch $_key $_default_value)
+              (send (const _ :Array) :new $_size $_default_value)
+            }
+            _args
+            _block_body)
+        PATTERN
+
+        def on_send(node)
+          unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
+            return
+          end
+          return if allowed_receiver?(node.receiver)
+          return if hash_without_braces?(default_value_node)
+
+          add_offense(default_value_node) do |corrector|
+            corrector.remove(prev_arg_node.source_range.end.join(default_value_node.source_range))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless OR (`||` and `or`) expressions.
+      #
+      # Some methods always return a truthy value, even when called
+      # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
+      # appended after these methods will never evaluate.
+      #
+      # @example
+      #
+      #   # bad
+      #   x.to_a || fallback
+      #   x.to_c || fallback
+      #   x.to_d || fallback
+      #   x.to_i || fallback
+      #   x.to_f || fallback
+      #   x.to_h || fallback
+      #   x.to_r || fallback
+      #   x.to_s || fallback
+      #   x.to_sym || fallback
+      #   x.intern || fallback
+      #   x.inspect || fallback
+      #   x.hash || fallback
+      #   x.object_id || fallback
+      #   x.__id__ || fallback
+      #
+      #   x.to_s or fallback
+      #
+      #   # good - if fallback is same as return value of method called on nil
+      #   x.to_a # nil.to_a returns []
+      #   x.to_c # nil.to_c returns (0+0i)
+      #   x.to_d # nil.to_d returns 0.0
+      #   x.to_i # nil.to_i returns 0
+      #   x.to_f # nil.to_f returns 0.0
+      #   x.to_h # nil.to_h returns {}
+      #   x.to_r # nil.to_r returns (0/1)
+      #   x.to_s # nil.to_s returns ''
+      #   x.to_sym # nil.to_sym raises an error
+      #   x.intern # nil.intern raises an error
+      #   x.inspect # nil.inspect returns "nil"
+      #   x.hash # nil.hash returns an Integer
+      #   x.object_id # nil.object_id returns an Integer
+      #   x.__id__ # nil.object_id returns an Integer
+      #
+      #   # good - if the intention is not to call the method on nil
+      #   x&.to_a || fallback
+      #   x&.to_c || fallback
+      #   x&.to_d || fallback
+      #   x&.to_i || fallback
+      #   x&.to_f || fallback
+      #   x&.to_h || fallback
+      #   x&.to_r || fallback
+      #   x&.to_s || fallback
+      #   x&.to_sym || fallback
+      #   x&.intern || fallback
+      #   x&.inspect || fallback
+      #   x&.hash || fallback
+      #   x&.object_id || fallback
+      #   x&.__id__ || fallback
+      #
+      #   x&.to_s or fallback
+      #
+      class UselessOr < Base
+        MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
+
+        TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
+                                          :to_s, :to_sym, :intern, :inspect, :hash, :object_id,
+                                          :__id__].freeze
+
+        # @!method truthy_return_value_method?(node)
+        def_node_matcher :truthy_return_value_method?, <<~PATTERN
+          (send _ %TRUTHY_RETURN_VALUE_METHODS)
+        PATTERN
+
+        def on_or(node)
+          if truthy_return_value_method?(node.lhs)
+            report_offense(node, node.lhs)
+          elsif truthy_return_value_method?(node.rhs)
+            parent = node.parent
+            parent = parent.parent if parent&.begin_type?
+
+            report_offense(parent, node.rhs) if parent&.or_type?
+          end
+        end
+
+        private
+
+        def report_offense(or_node, truthy_node)
+          add_offense(or_node.loc.operator.join(or_node.rhs.source_range),
+                      message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source))
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      # Checks for useless ``rescue``s, which only reraise rescued exceptions.
       #
       # @example
       #   # bad

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

@@ -89,7 +89,7 @@ module RuboCop
         private
 
         def inspect_def(node, def_node)
-          return if allowed_arguments(def_node.arguments)
+          return if allowed_arguments?(def_node.arguments)
 
           add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
         end
@@ -101,7 +101,7 @@ module RuboCop
           definition = find_method_definition(node, method_name)
 
           return unless definition
-          return if allowed_arguments(definition.arguments)
+          return if allowed_arguments?(definition.arguments)
 
           add_offense(node, message: format(MSG, method_name: method_name))
         end
@@ -115,7 +115,7 @@ module RuboCop
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
-        def allowed_arguments(arguments)
+        def allowed_arguments?(arguments)
           return false if arguments.empty?
 
           arguments.each_child_node(:restarg).any? &&

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

@@ -128,8 +128,8 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
-          node = node.children.first while node.begin_type?
-          return unless node.call_type? && OPERATORS.include?(node.method_name)
+          node = node.children.first while node&.begin_type?
+          return unless node&.call_type? && OPERATORS.include?(node.method_name)
           if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
             return
           end

data/lib/rubocop/cop/message_annotator.rb

@@ -32,7 +32,7 @@ module RuboCop
       # @param [String] cop_name for specific cop name
       # @param [Hash] cop_config configs for specific cop, from config#for_cop
       # @option cop_config [String] :StyleGuide Extension of base styleguide URL
-      # @option cop_config [String] :Reference Full reference URL
+      # @option cop_config [String] :References Full reference URLs
       # @option cop_config [String] :Details
       #
       # @param [Hash, nil] options optional
@@ -100,8 +100,12 @@ module RuboCop
       end
 
       def reference_urls
-        urls = Array(cop_config['Reference'])
-        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
+        urls = cop_config
+               .values_at('References', 'Reference') # Support legacy Reference key
+               .flat_map { Array(_1) }
+               .reject(&:empty?)
+
+        urls unless urls.empty?
       end
 
       def extra_details?

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -39,7 +39,7 @@ module RuboCop
       class AbcSize < Base
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
               '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private

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

@@ -66,7 +66,7 @@ module RuboCop
       end
 
       # @deprecated Use processed_source.line_with_comment?(line)
-      def end_of_line_comment(line)
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
         WARNING

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

@@ -48,7 +48,7 @@ module RuboCop
 
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
-        elsif node.type?(:def, :defs)
+        elsif node.any_def_type?
           return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
@@ -220,7 +220,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.last_argument.last_line if node.type?(:def, :defs)
+        return node.first_line != node.last_argument.last_line if node.any_def_type?
 
         !node.single_line?
       end

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

@@ -40,7 +40,7 @@ module RuboCop
       end
 
       def safe_to_split?(node)
-        node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
+        node.each_descendant(:if, :case, :kwbegin, :any_def).none? &&
           node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
           node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
       end

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

@@ -19,7 +19,7 @@ module RuboCop
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected :private_class_method} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} (any_def ...))
       PATTERN
     end
   end

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

@@ -21,7 +21,7 @@ module RuboCop
 
         # @!method empty_line_required?(node)
         def_node_matcher :empty_line_required?,
-                         '{def defs class module (send nil? {:private :protected :public})}'
+                         '{any_def class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)

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

@@ -6,7 +6,6 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 
@@ -90,7 +89,7 @@ module RuboCop
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index
-          processed_source.lines[0...first_non_comment_token.line - 1]
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
         else
           processed_source.lines
         end

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

@@ -25,6 +25,28 @@ module RuboCop
           (args
             (arg $_)) ...)
       PATTERN
+
+      # @!method assignment_method_declarations(node)
+      def_node_search :assignment_method_declarations, <<~PATTERN
+        (send
+          (lvar {#match_block_variable_name? :_1 :it}) _ ...)
+      PATTERN
+
+      # @!method indexed_assignment_method_declarations(node)
+      def_node_search :indexed_assignment_method_declarations, <<~PATTERN
+        (send
+          (send (lvar {#match_block_variable_name? :_1 :it}) _)
+          :[]=
+          literal?
+          _
+        )
+      PATTERN
+
+      def match_block_variable_name?(receiver_name)
+        gem_specification(processed_source.ast) do |block_variable_name|
+          return block_variable_name == receiver_name
+        end
+      end
     end
   end
 end

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

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -81,13 +81,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -97,30 +91,37 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 - current_pair.loc.operator.column
+          first_pair.loc.column + max_key_width(first_pair.parent) + 1 -
+            current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
           correct_value_column = first_pair.key.loc.column +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
+                                 max_key_width(first_pair.parent) +
+                                 max_delimiter_width(first_pair.parent)
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
+
+        def max_key_width(hash_node)
+          hash_node.keys.map { |key| key.source.length }.max
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
+        end
       end
 
       # Handles calculation of deltas when the enforced style is 'separator'.
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         end