rubocop 1.42.0 → 1.64.1

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
@@ -82,16 +81,23 @@ module RuboCop
         def autocorrect(corrector, offense_range:, send_node:)
           corrector.replace(
             offense_range,
-            add_safe_navigation_operator(
-              offense_range: offense_range,
-              send_node: send_node
-            )
+            add_safe_navigation_operator(offense_range: offense_range, send_node: send_node)
           )
+
+          corrector.wrap(send_node, '(', ')') if require_parentheses?(send_node)
         end
 
         def brackets?(send_node)
           send_node.method?(:[]) || send_node.method?(:[]=)
         end
+
+        def require_parentheses?(send_node)
+          return false unless send_node.comparison_method?
+          return false unless (node = send_node.parent)
+
+          (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
+            (node.respond_to?(:comparison_method?) && node.comparison_method?)
+        end
       end
     end
   end

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

@@ -65,7 +65,7 @@ module RuboCop
         end
 
         def location(node, unsafe_method_call)
-          node.loc.expression.join(unsafe_method_call.loc.expression)
+          node.source_range.join(unsafe_method_call.source_range)
         end
 
         def top_conditional_ancestor(node)

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,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,28 @@ 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
       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

@@ -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

@@ -68,7 +68,7 @@ module RuboCop
 
         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)
@@ -96,6 +96,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/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

@@ -117,9 +117,9 @@ module RuboCop
 
         def comment_between_rescue_and_end?(node)
           ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
-          return unless ancestor
+          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
 

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)
@@ -124,7 +129,7 @@ module RuboCop
           source == value ||
             # `Symbol#inspect` uses double quotes, but allow single-quoted
             # symbols to work as well.
-            source.tr("'", '"') == value
+            source.gsub('"', '\"').tr("'", '"') == value
         end
 
         def requires_quotes?(sym_node)

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

@@ -17,9 +17,12 @@ module RuboCop
         private
 
         def add_offense_from_diagnostic(diagnostic, ruby_version)
-          message =
-            "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          message = if LSP.enabled?
+                      diagnostic.message
+                    else
+                      "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+                        'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+                    end
           add_offense(diagnostic.location, message: message, severity: diagnostic.level)
         end
 
@@ -33,6 +36,10 @@ module RuboCop
           message << '.' unless message.end_with?('.')
           message
         end
+
+        def find_severity(_range, _severity)
+          :fatal
+        end
       end
     end
   end

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

@@ -14,8 +14,14 @@ module RuboCop
       #
       #   # good
       #   def foo(x, y = 1)
+      #     # Alternatives to `__callee__` are `__method__` and `:foo`.
       #     return to_enum(__callee__, x, y)
-      #     # alternatives to `__callee__` are `__method__` and `:foo`
+      #   end
+      #
+      #   # good
+      #   def foo(x, y = 1)
+      #     # It is also allowed if it is wrapped in some method like Sorbet.
+      #     return to_enum(T.must(__callee__), x, y)
       #   end
       #
       class ToEnumArguments < Base
@@ -43,8 +49,17 @@ module RuboCop
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|
-            add_offense(node) unless method_name?(method_node, def_node.method_name) &&
-                                     arguments_match?(arguments, def_node)
+            next if method_node.call_type? &&
+                    !method_node.method?(:__method__) && !method_node.method?(:__callee__)
+
+            valid = if method_name?(method_node, def_node.method_name)
+                      arguments_match?(arguments, def_node)
+                    else
+                      def_node.arguments.empty?
+                    end
+            return if valid
+
+            add_offense(node)
           end
         end
 
@@ -64,7 +79,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -77,12 +92,14 @@ module RuboCop
             send_arg.hash_type? &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
-            send_arg.each_child_node(:kwsplat).any? { |child| child.source == def_arg.source }
+            send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
+              child.source == def_arg.source
+            end
           when :forward_arg
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       end
     end
   end

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

@@ -8,25 +8,39 @@ module RuboCop
       # always ignored. This is detected automatically since Ruby 2.7.
       #
       # @example
+      #   # bad
+      #   return 1
       #
-      #   # Detected since Ruby 2.7
-      #   return 1 # 1 is always ignored.
+      #   # good
+      #   return
       class TopLevelReturnWithArgument < Base
-        # This cop works by validating the ancestors of the return node. A
-        # top-level return node's ancestors should not be of block, def, or
-        # defs type.
+        extend AutoCorrector
 
         MSG = 'Top level return with argument detected.'
 
         def on_return(return_node)
-          add_offense(return_node) if return_node.arguments? && ancestors_valid?(return_node)
+          return unless top_level_return_with_any_argument?(return_node)
+
+          add_offense(return_node) do |corrector|
+            remove_arguments(corrector, return_node)
+          end
         end
 
         private
 
-        def ancestors_valid?(return_node)
-          prohibited_ancestors = return_node.each_ancestor(:block, :def, :defs)
-          prohibited_ancestors.none?
+        def top_level_return_with_any_argument?(return_node)
+          top_level_return?(return_node) && return_node.arguments?
+        end
+
+        def remove_arguments(corrector, return_node)
+          corrector.replace(return_node, 'return')
+        end
+
+        # This cop works by validating the ancestors of the return node. A
+        # 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?
         end
       end
     end

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

@@ -69,8 +69,8 @@ module RuboCop
         # @!method reduce_with_block?(node)
         def_node_matcher :reduce_with_block?, <<~PATTERN
           {
-            (block (send _recv {:reduce :inject} ...) args ...)
-            (numblock (send _recv {:reduce :inject} ...) ...)
+            (block (call _recv {:reduce :inject} ...) args ...)
+            (numblock (call _recv {:reduce :inject} ...) ...)
           }
         PATTERN
 

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

@@ -71,7 +71,7 @@ module RuboCop
             expressions.any? { |expr| flow_expression?(expr) }
           when :if
             check_if(node)
-          when :case
+          when :case, :case_match
             check_case(node)
           else
             false
@@ -89,7 +89,9 @@ module RuboCop
           return false unless else_branch
           return false unless flow_expression?(else_branch)
 
-          node.when_branches.all? { |branch| branch.body && flow_expression?(branch.body) }
+          branches = node.case_type? ? node.when_branches : node.in_pattern_branches
+
+          branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
       end
     end

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

@@ -111,9 +111,9 @@ module RuboCop
           return false unless node.block_type? || node.numblock_type?
 
           send_node = node.send_node
-          return false if matches_allowed_pattern?(send_node.source)
-
-          send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
         end
 
         def check(node)
@@ -160,7 +160,7 @@ module RuboCop
             break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
-          when :case
+          when :case, :case_match
             check_case(node)
           else
             false
@@ -178,7 +178,13 @@ module RuboCop
           return false unless else_branch
           return false unless break_statement?(else_branch)
 
-          node.when_branches.all? { |branch| branch.body && break_statement?(branch.body) }
+          branches = if node.case_type?
+                       node.when_branches
+                     else
+                       node.in_pattern_branches
+                     end
+
+          branches.all? { |branch| branch.body && break_statement?(branch.body) }
         end
 
         def preceded_by_continue_statement?(break_statement)

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

@@ -137,7 +137,7 @@ module RuboCop
         alias on_sclass on_class
 
         def on_block(node)
-          return unless eval_call?(node)
+          return unless eval_call?(node) || included_block?(node)
 
           check_node(node.body)
         end
@@ -167,11 +167,6 @@ module RuboCop
           ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          ({block numblock} (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
-        PATTERN
-
         def check_node(node)
           return if node.nil?
 
@@ -197,10 +192,13 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
               cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -212,6 +210,7 @@ module RuboCop
 
           [cur_vis, unused]
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
@@ -245,6 +244,10 @@ module RuboCop
           [new_vis, unused]
         end
 
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
         def method_definition?(child)
           static_method_definition?(child) ||
             dynamic_method_definition?(child) ||
@@ -253,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} ...)}
@@ -270,13 +273,13 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            child.class_constructor? ||
             any_context_creating_methods?(child)
         end
 
         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}} ...) ...)