rubocop 1.65.1 → 1.75.6

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

@@ -3,88 +3,156 @@
 module RuboCop
   module Cop
     module Lint
-      # Check to make sure that if safe navigation is used for a method
-      # call in an `&&` or `||` condition that safe navigation is used for all
-      # method calls on that same object.
+      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # consistent and appropriate safe navigation, without excess or deficiency,
+      # is used for all method calls on the same object.
       #
       # @example
       #   # bad
-      #   foo&.bar && foo.baz
+      #   foo&.bar && foo&.baz
       #
-      #   # bad
-      #   foo.bar || foo&.baz
+      #   # good
+      #   foo&.bar && foo.baz
       #
       #   # bad
-      #   foo&.bar && (foobar.baz || foo.baz)
+      #   foo.bar && foo&.baz
       #
       #   # good
       #   foo.bar && foo.baz
       #
+      #   # bad
+      #   foo&.bar || foo.baz
+      #
       #   # good
       #   foo&.bar || foo&.baz
       #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
       #   # good
+      #   foo.bar || foo.baz
+      #
+      #   # bad
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
       class SafeNavigationConsistency < Base
-        include IgnoredNode
         include NilMethods
         extend AutoCorrector
 
-        MSG = 'Ensure that safe navigation is used consistently inside of `&&` and `||`.'
+        USE_DOT_MSG = 'Use `.` instead of unnecessary `&.`.'
+        USE_SAFE_NAVIGATION_MSG = 'Use `&.` for consistency with safe navigation.'
 
-        def on_csend(node)
-          return unless node.parent&.operator_keyword?
+        def on_and(node)
+          all_operands = collect_operands(node, [])
+          operand_groups = all_operands.group_by { |operand| receiver_name_as_key(operand, +'') }
 
-          check(node)
-        end
+          operand_groups.each_value do |grouped_operands|
+            next unless (dot_op, begin_of_rest_operands = find_consistent_parts(grouped_operands))
 
-        def check(node)
-          ancestor = top_conditional_ancestor(node)
-          conditions = ancestor.conditions
-          safe_nav_receiver = node.receiver
+            rest_operands = grouped_operands[begin_of_rest_operands..]
+            rest_operands.each do |operand|
+              next if already_appropriate_call?(operand, dot_op)
 
-          method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls = unsafe_method_calls(method_calls, safe_nav_receiver)
+              register_offense(operand, dot_op)
+            end
+          end
+        end
+        alias on_or on_and
 
-          unsafe_method_calls.each do |unsafe_method_call|
-            location = location(node, unsafe_method_call)
+        private
 
-            add_offense(location) { |corrector| autocorrect(corrector, unsafe_method_call) }
+        def collect_operands(node, operand_nodes)
+          operand_nodes(node.lhs, operand_nodes)
+          operand_nodes(node.rhs, operand_nodes)
 
-            ignore_node(unsafe_method_call)
+          operand_nodes
+        end
+
+        def receiver_name_as_key(method, fully_receivers)
+          if method.parent.call_type?
+            receiver(method.parent, fully_receivers)
+          else
+            fully_receivers << method.receiver&.source.to_s
           end
         end
 
-        private
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_consistent_parts(grouped_operands)
+          csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
-        def autocorrect(corrector, node)
-          return unless node.dot?
+          return if csend_in_and && csend_in_or && csend_in_and < csend_in_or
 
-          corrector.insert_before(node.loc.dot, '&')
+          if csend_in_and
+            ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
+          elsif send_in_or && csend_in_or
+            send_in_or < csend_in_or ? ['.', send_in_or + 1] : ['&.', csend_in_or + 1]
+          elsif send_in_and && csend_in_or && send_in_and < csend_in_or
+            ['.', csend_in_or]
+          end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def location(node, unsafe_method_call)
-          node.source_range.join(unsafe_method_call.source_range)
+        def already_appropriate_call?(operand, dot_op)
+          return true if operand.safe_navigation? && dot_op == '&.'
+
+          (operand.dot? || operand.operator_method?) && dot_op == '.'
         end
 
-        def top_conditional_ancestor(node)
-          parent = node.parent
-          unless parent &&
-                 (parent.operator_keyword? ||
-                  (parent.begin_type? && parent.parent && parent.parent.operator_keyword?))
-            return node
+        def register_offense(operand, dot_operator)
+          offense_range = operand.operator_method? ? operand : operand.loc.dot
+          message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG
+
+          add_offense(offense_range, message: message) do |corrector|
+            next if operand.operator_method?
+
+            corrector.replace(operand.loc.dot, dot_operator)
           end
+        end
 
-          top_conditional_ancestor(parent)
+        def operand_nodes(operand, operand_nodes)
+          if operand.operator_keyword?
+            collect_operands(operand, operand_nodes)
+          elsif operand.call_type?
+            operand_nodes << operand
+          end
         end
 
-        def unsafe_method_calls(method_calls, safe_nav_receiver)
-          method_calls.select do |method_call|
-            safe_nav_receiver == method_call.receiver &&
-              !nil_methods.include?(method_call.method_name) &&
-              !ignored_node?(method_call)
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def most_left_indices(grouped_operands)
+          indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
+
+          grouped_operands.each_with_index do |operand, index|
+            indices[:csend_in_and] ||= index if operand_in_and?(operand) && operand.csend_type?
+            indices[:csend_in_or] ||= index if operand_in_or?(operand) && operand.csend_type?
+            indices[:send_in_and] ||= index if operand_in_and?(operand) && !nilable?(operand)
+            indices[:send_in_or] ||= index if operand_in_or?(operand) && !nilable?(operand)
           end
+
+          indices.values
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def operand_in_and?(node)
+          return true if node.parent.and_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.and_type?
+        end
+
+        def operand_in_or?(node)
+          return true if node.parent.or_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.or_type?
+        end
+
+        def nilable?(node)
+          node.csend_type? || nil_methods.include?(node.method_name)
         end
       end
     end

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

@@ -43,23 +43,21 @@ module RuboCop
         alias on_csend on_send
 
         def on_lvasgn(node)
-          lhs, rhs = *node
-          return unless rhs
+          return unless node.rhs
 
           rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
 
-          add_offense(node) if rhs.type == rhs_type && rhs.source == lhs.to_s
+          add_offense(node) if node.rhs.type == rhs_type && node.rhs.source == node.lhs.to_s
         end
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
         def on_casgn(node)
-          lhs_scope, lhs_name, rhs = *node
-          return unless rhs&.const_type?
+          return unless node.rhs&.const_type?
 
-          rhs_scope, rhs_name = *rhs
-          add_offense(node) if lhs_scope == rhs_scope && lhs_name == rhs_name
+          add_offense(node) if node.namespace == node.rhs.namespace &&
+                               node.short_name == node.rhs.short_name
         end
 
         def on_masgn(node)
@@ -67,15 +65,15 @@ module RuboCop
         end
 
         def on_or_asgn(node)
-          lhs, rhs = *node
-          add_offense(node) if rhs_matches_lhs?(rhs, lhs)
+          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
         end
         alias on_and_asgn on_or_asgn
 
         private
 
         def multiple_self_assignment?(node)
-          lhs, rhs = *node
+          lhs = node.lhs
+          rhs = node.rhs
           return false unless rhs.array_type?
           return false unless lhs.children.size == rhs.children.size
 

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

@@ -67,7 +67,7 @@ module RuboCop
         def on_rescue(node)
           return if rescue_modifier?(node)
 
-          _body, *rescues, _else = *node
+          rescues = node.resbody_branches
           rescued_groups = rescued_groups_for(rescues)
 
           rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|

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

@@ -56,19 +56,26 @@ module RuboCop
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
+          return if variable_used_in_declaration_of_outer?(variable, outer_local_variable)
           return if same_conditions_node_different_branch?(variable, outer_local_variable)
 
           message = format(MSG, variable: variable.name)
           add_offense(variable.declaration_node, message: message)
         end
 
+        private
+
+        def variable_used_in_declaration_of_outer?(variable, outer_local_variable)
+          variable.scope.node.each_ancestor.any?(outer_local_variable.declaration_node)
+        end
+
         def same_conditions_node_different_branch?(variable, outer_local_variable)
           variable_node = variable_node(variable)
           return false unless node_or_its_ascendant_conditional?(variable_node)
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
-          return true unless outer_local_variable_node
+          return false unless outer_local_variable_node
           return false unless outer_local_variable_node.conditional?
           return true if variable_node == outer_local_variable_node
 

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `Hash` creation with a mutable default value.
+      # Creating a `Hash` in such a way will share the default value
+      # across all keys, causing unexpected behavior when modifying it.
+      #
+      # For example, when the `Hash` was created with an `Array` as the argument,
+      # calling `hash[:foo] << 'bar'` will also change the value of all
+      # other keys that have not been explicitly assigned to.
+      #
+      # @example
+      #   # bad
+      #   Hash.new([])
+      #   Hash.new({})
+      #   Hash.new(Array.new)
+      #   Hash.new(Hash.new)
+      #
+      #   # okay -- In rare cases that intentionally have this behavior,
+      #   #   without disabling the cop, you can set the default explicitly.
+      #   h = Hash.new
+      #   h.default = []
+      #   h[:a] << 1
+      #   h[:b] << 2
+      #   h # => {:a => [1, 2], :b => [1, 2]}
+      #
+      #   # okay -- beware this will discard mutations and only remember assignments
+      #   Hash.new { Array.new }
+      #   Hash.new { Hash.new }
+      #   Hash.new { {} }
+      #   Hash.new { [] }
+      #
+      #   # good - frozen solution will raise an error when mutation attempted
+      #   Hash.new([].freeze)
+      #   Hash.new({}.freeze)
+      #
+      #   # good - using a proc will create a new object for each key
+      #   h = Hash.new
+      #   h.default_proc = ->(h, k) { [] }
+      #   h.default_proc = ->(h, k) { {} }
+      #
+      #   # good - using a block will create a new object for each key
+      #   Hash.new { |h, k| h[k] = [] }
+      #   Hash.new { |h, k| h[k] = {} }
+      class SharedMutableDefault < Base
+        MSG = 'Do not create a Hash with a mutable default value ' \
+              'as the default value can accidentally be changed.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_initialized_with_mutable_shared_object?(node)
+        def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Hash) :new [
+              {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
+              !#capacity_keyword_argument?
+            ])
+            (send (const {nil? cbase} :Hash) :new hash #capacity_keyword_argument?)
+          }
+        PATTERN
+
+        # @!method capacity_keyword_argument?(node)
+        def_node_matcher :capacity_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :capacity) _))
+        PATTERN
+
+        def on_send(node)
+          return unless hash_initialized_with_mutable_shared_object?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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, :block, :numblock).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/suppressed_exception_in_number_conversion.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for cases where exceptions unrelated to the numeric constructors `Integer()`,
+      # `Float()`, `BigDecimal()`, `Complex()`, and `Rational()` may be unintentionally swallowed.
+      #
+      # @safety
+      #   The cop is unsafe for autocorrection because unexpected errors occurring in the argument
+      #   passed to numeric constructor (e.g., `Integer()`) can lead to incompatible behavior.
+      #   For example, changing it to `Integer(potential_exception_method_call, exception: false)`
+      #   ensures that exceptions raised by `potential_exception_method_call` are not ignored.
+      #
+      #   [source,ruby]
+      #   ----
+      #   Integer(potential_exception_method_call) rescue nil
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Integer(arg) rescue nil
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   Integer(arg, exception: false)
+      #
+      class SuppressedExceptionInNumberConversion < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        EXPECTED_EXCEPTION_CLASSES = %w[ArgumentError TypeError ::ArgumentError ::TypeError].freeze
+
+        # @!method numeric_constructor_rescue_nil(node)
+        def_node_matcher :numeric_constructor_rescue_nil, <<~PATTERN
+          (rescue
+            $#numeric_method?
+            (resbody nil? nil? (nil)) nil?)
+        PATTERN
+
+        # @!method begin_numeric_constructor_rescue_nil(node)
+        def_node_matcher :begin_numeric_constructor_rescue_nil, <<~PATTERN
+          (kwbegin
+            (rescue
+              $#numeric_method?
+              (resbody $_? nil?
+                {(nil) nil?}) nil?))
+        PATTERN
+
+        # @!method numeric_method?(node)
+        def_node_matcher :numeric_method?, <<~PATTERN
+          {
+            (call #constructor_receiver? {:Integer :BigDecimal :Complex :Rational}
+              _ _?)
+            (call #constructor_receiver? :Float
+              _)
+          }
+        PATTERN
+
+        # @!method constructor_receiver?(node)
+        def_node_matcher :constructor_receiver?, <<~PATTERN
+          {nil? (const {nil? cbase} :Kernel)}
+        PATTERN
+
+        minimum_target_ruby_version 2.6
+
+        # rubocop:disable Metrics/AbcSize
+        def on_rescue(node)
+          if (method, exception_classes = begin_numeric_constructor_rescue_nil(node.parent))
+            return unless expected_exception_classes_only?(exception_classes)
+
+            node = node.parent
+          else
+            return unless (method = numeric_constructor_rescue_nil(node))
+          end
+
+          arguments = method.arguments.map(&:source) << 'exception: false'
+          prefer = "#{method.method_name}(#{arguments.join(', ')})"
+          prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def expected_exception_classes_only?(exception_classes)
+          return true unless (arguments = exception_classes.first)
+
+          (arguments.values.map(&:source) - EXPECTED_EXCEPTION_CLASSES).none?
+        end
+      end
+    end
+  end
+end

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

@@ -78,7 +78,7 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if node.receiver.str_type? || node.receiver.sym_type?
+          if node.receiver.type?(:str, :sym)
             register_offense(node, correction: node.receiver.value.to_sym.inspect)
           elsif node.receiver.dstr_type?
             register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def in_percent_literal_array?(node)
-          node.parent&.array_type? && node.parent&.percent_literal?
+          node.parent&.array_type? && node.parent.percent_literal?
         end
 
         def correct_hash_key(node)

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

@@ -6,9 +6,12 @@ module RuboCop
       # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-          processed_source.diagnostics.each do |diagnostic|
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
             add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super

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/unescaped_bracket_in_regexp.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # that contain unescaped `]` characters.
+      #
+      # It emulates the following Ruby warning:
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '/abc]123/'
+      # -e:1: warning: regular expression has ']' without escape: /abc]123/
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /abc]123/
+      #   %r{abc]123}
+      #   Regexp.new('abc]123')
+      #   Regexp.compile('abc]123')
+      #
+      #   # good
+      #   /abc\]123/
+      #   %r{abc\]123}
+      #   Regexp.new('abc\]123')
+      #   Regexp.compile('abc\]123')
+      #
+      class UnescapedBracketInRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Regular expression has `]` without escape.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method regexp_constructor(node)
+        def_node_search :regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            $str
+            ...
+          )
+        PATTERN
+
+        def on_regexp(node)
+          RuboCop::Util.silence_warnings do
+            node.parsed_tree&.each_expression do |expr|
+              detect_offenses(node, expr)
+            end
+          end
+        end
+
+        def on_send(node)
+          # Ignore nodes that contain interpolation
+          return if node.each_descendant(:dstr).any?
+
+          regexp_constructor(node) do |text|
+            parse_regexp(text.value)&.each_expression do |expr|
+              detect_offenses(text, expr)
+            end
+          end
+        end
+
+        private
+
+        def detect_offenses(node, expr)
+          return unless expr.type?(:literal)
+
+          expr.text.scan(/(?<!\\)\]/) do
+            pos = Regexp.last_match.begin(0)
+            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+
+            location = range_at_index(node, expr.ts, pos)
+
+            add_offense(location) do |corrector|
+              corrector.replace(location, '\]')
+            end
+          end
+        end
+
+        def range_at_index(node, index, offset)
+          adjustment = index + offset
+          node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -74,6 +75,7 @@ module RuboCop
 
         def arg_count(node)
           return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+          return 1 if node.itblock_type? # `it` block parameter is always one
 
           # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
           # can be used. Keyword arguments are not used for these methods so are
@@ -81,7 +83,7 @@ module RuboCop
           node.arguments.count do |arg|
             return Float::INFINITY if arg.restarg_type?
 
-            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+            arg.type?(:arg, :optarg, :mlhs)
           end
         end
       end

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

@@ -130,7 +130,7 @@ module RuboCop
 
           block_body_node.each_descendant(:next, :break) do |n|
             # Ignore `next`/`break` inside an inner block
-            next if n.each_ancestor(:block).first != block_body_node.parent
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
             next unless n.first_argument
 
             nodes << n.first_argument