rubocop 1.44.1 → 1.78.0

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.loc.expression.join(unsafe_method_call.loc.expression)
+        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/script_permission.rb

@@ -46,14 +46,14 @@ module RuboCop
           message = format_message_from(processed_source)
 
           add_offense(comment, message: message) do
-            autocorrect(comment) if autocorrect_requested?
+            autocorrect if autocorrect_requested?
           end
         end
 
         private
 
-        def autocorrect(comment)
-          FileUtils.chmod('+x', comment.loc.expression.source_buffer.name)
+        def autocorrect
+          FileUtils.chmod('+x', processed_source.file_path)
         end
 
         def executable?(processed_source)

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

@@ -10,11 +10,26 @@ 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]
+      #
+      # @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.'
@@ -26,40 +41,56 @@ module RuboCop
           gvasgn: :gvar
         }.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?
+            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
+          return unless node.rhs
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(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?
+          return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.rhs)
 
-          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)
+          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)
-          lhs, rhs = *node
-          add_offense(node) if rhs_matches_lhs?(rhs, lhs)
+          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
 
         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
 
@@ -72,6 +103,36 @@ 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
+          return unless first_argument.respond_to?(:arguments) && first_argument.arguments.empty?
+
+          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
+
+        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/send_with_mixin_argument.rb

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      #
-      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # Checks for `send`, `public_send`, and `__send__` methods
       # when using mix-in.
       #
       # `include` and `prepend` methods were private methods until Ruby 2.0,

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

@@ -123,6 +123,7 @@ module RuboCop
 
             # Shorthand assignments always use their arguments
             next false if assignment_node.shorthand_asgn?
+            next false unless assignment_node.parent
 
             node_within_block_or_conditional =
               node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)

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|
@@ -83,7 +83,7 @@ module RuboCop
 
         def offense_range(rescues)
           shadowing_rescue = find_shadowing_rescue(rescues)
-          expression = shadowing_rescue.loc.expression
+          expression = shadowing_rescue.source_range
           range_between(expression.begin_pos, expression.end_pos)
         end
 
@@ -121,18 +121,12 @@ module RuboCop
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
-              # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              #        https://github.com/jruby/jruby/issues/6642
-              # rubocop:disable Style/RedundantBegin
-              begin
-                RuboCop::Util.silence_warnings do
-                  # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception.source)
-                end
-              rescue NameError
-                converted << nil
+              RuboCop::Util.silence_warnings do
+                # Avoid printing deprecation warnings about constants
+                converted << Kernel.const_get(exception.source)
               end
-              # rubocop:enable Style/RedundantBegin
+            rescue NameError
+              converted << nil
             end
           else
             # treat an empty `rescue` as `rescue StandardError`

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

@@ -8,21 +8,25 @@ 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:
       #
-      #   [source,ruby]
-      #   ----
-      #   worker_id, pipe = env
-      #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
-      #   end
-      #   ----
+      # [source,ruby]
+      # ----
+      # worker_id, pipe = env
+      # Ractor.new(worker_id, pipe) do |worker_id, pipe|
+      # end
+      # ----
       #
       # @example
       #
       #   # bad
-      #
       #   def some_method
       #     foo = 1
       #
@@ -31,10 +35,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method
       #     foo = 1
       #
@@ -60,19 +61,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 variable_node.conditional?
+          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
 
@@ -96,6 +104,12 @@ module RuboCop
 
           find_conditional_node_from_ascendant(parent)
         end
+
+        def node_or_its_ascendant_conditional?(node)
+          return true if node.conditional?
+
+          !!find_conditional_node_from_ascendant(node)
+        end
       end
     end
   end

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

@@ -32,25 +32,25 @@ module RuboCop
         # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
-            (const ${nil? cbase} :Struct) :new ...)
+            (const {nil? cbase} :Struct) :new ...)
         PATTERN
 
         def on_send(node)
-          return unless struct_new(node) do
-            node.arguments.each_with_index do |arg, index|
-              # Ignore if the first argument is a class name
-              next if index.zero? && arg.str_type?
+          return unless struct_new(node)
 
-              # Ignore if the argument is not a member name
-              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+          node.arguments.each_with_index do |arg, index|
+            # Ignore if the first argument is a class name
+            next if index.zero? && arg.str_type?
 
-              member_name = arg.value
+            # Ignore if the argument is not a member name
+            next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
 
-              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+            member_name = arg.value
 
-              message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
-              add_offense(arg, message: message)
-            end
+            next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+            message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
+            add_offense(arg, message: message)
           end
         end
       end

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

@@ -116,10 +116,10 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
-          return unless ancestor
+          ancestor = node.each_ancestor(:kwbegin, :any_def, :any_block).first
+          return false unless ancestor
 
-          end_line = ancestor.loc.end.line
+          end_line = ancestor.loc.end&.line || ancestor.loc.last_line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end