rubocop 1.30.1 → 1.64.0

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

@@ -46,7 +46,9 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return unless ternary.condition.operator_keyword?
+          if node.method?(:[]) || node.assignment_method? || !ternary.condition.operator_keyword?
+            return
+          end
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that a range literal is enclosed in parentheses when the end of the range is
+      # at a line break.
+      #
+      # NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`.
+      # So, this cop does not provide autocorrection because it is left to user.
+      #
+      # [source,ruby]
+      # ----
+      # case condition
+      # when 42..
+      #   do_something
+      # end
+      # ----
+      #
+      # @example
+      #
+      #   # bad - Represents `(1..42)`, not endless range.
+      #   1..
+      #   42
+      #
+      #   # good - It's incompatible, but your intentions when using endless range may be:
+      #   (1..)
+      #   42
+      #
+      #   # good
+      #   1..42
+      #
+      #   # good
+      #   (1..42)
+      #
+      #   # good
+      #   (1..
+      #   42)
+      #
+      class RequireRangeParentheses < Base
+        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+
+        def on_irange(node)
+          return if node.parent&.begin_type?
+          return unless node.begin && node.end
+          return if same_line?(node.begin, node.end)
+
+          message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
+
+          add_offense(node, message: message)
+        end
+
+        alias on_erange on_irange
+      end
+    end
+  end
+end

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

@@ -50,7 +50,7 @@ module RuboCop
           return if invalid_exceptions.empty?
 
           add_offense(
-            node.loc.keyword.join(rescued.loc.expression),
+            node.loc.keyword.join(rescued.source_range),
             message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
@@ -59,9 +59,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                            node.loc.keyword.end_pos,
-                                            rescued.loc.expression.end_pos)
+          range = node.loc.keyword.end.join(rescued.source_range.end)
 
           corrector.replace(range, correction(*rescued))
         end

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

@@ -25,11 +25,13 @@ module RuboCop
       #   x&.foo || bar
       class SafeNavigationChain < Base
         include NilMethods
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.3
 
         MSG = 'Do not chain ordinary method call after safe navigation operator.'
+        PLUS_MINUS_METHODS = %i[+@ -@].freeze
 
         # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
@@ -41,23 +43,60 @@ module RuboCop
 
         def on_send(node)
           bad_method?(node) do |safe_nav, method|
-            return if nil_methods.include?(method)
+            return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
-            method_chain = method_chain(node)
-            location =
-              Parser::Source::Range.new(node.source_range.source_buffer,
-                                        safe_nav.source_range.end_pos,
-                                        method_chain.source_range.end_pos)
-            add_offense(location)
+            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
           end
         end
 
         private
 
-        def method_chain(node)
-          chain = node
-          chain = chain.parent if chain.send_type? && chain.parent&.call_type?
-          chain
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        # @return [String]
+        def add_safe_navigation_operator(offense_range:, send_node:)
+          source =
+            if brackets?(send_node)
+              format(
+                '%<method_name>s(%<arguments>s)%<method_chain>s',
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name,
+                method_chain: send_node.source_range.end.join(send_node.source_range.end).source
+              )
+            else
+              offense_range.source
+            end
+          source.prepend('.') unless source.start_with?('.')
+          source.prepend('&')
+        end
+
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        def autocorrect(corrector, offense_range:, send_node:)
+          corrector.replace(
+            offense_range,
+            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

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,
@@ -48,16 +47,17 @@ module RuboCop
           (send
             (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
-              $(const _ _))
+              $(const _ _)+)
         PATTERN
 
         def on_send(node)
-          send_with_mixin_argument?(node) do |method, module_name|
-            message = message(method, module_name.source, bad_location(node).source)
+          send_with_mixin_argument?(node) do |method, module_names|
+            module_names_source = module_names.map(&:source).join(', ')
+            message = message(method, module_names_source, bad_location(node).source)
 
             bad_location = bad_location(node)
             add_offense(bad_location, message: message) do |corrector|
-              corrector.replace(bad_location, "#{method} #{module_name.source}")
+              corrector.replace(bad_location, "#{method} #{module_names_source}")
             end
           end
         end

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

@@ -7,6 +7,14 @@ module RuboCop
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #
+      # An exception is considered shadowed if it is rescued after its
+      # ancestor is, or if it and its ancestor are both rescued in the
+      # same `rescue` statement. In both cases, the more specific rescue is
+      # unnecessary because it is covered by rescuing the less specific
+      # exception. (ie. `rescue Exception, StandardError` has the same behavior
+      # whether `StandardError` is included or not, because all ``StandardError``s
+      # are rescued by `rescue Exception`).
+      #
       # @example
       #
       #   # bad
@@ -19,6 +27,13 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue Exception, StandardError
+      #     handle_error
+      #   end
+      #
       #   # good
       #
       #   begin
@@ -68,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
 
@@ -106,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`
@@ -140,16 +149,6 @@ module RuboCop
           end
         end
 
-        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
-        def rescued_exceptions(rescue_group)
-          klasses = *rescue_group
-          klasses.map do |klass|
-            next unless klass.const_type?
-
-            klass.source
-          end.compact
-        end
-
         def find_shadowing_rescue(rescues)
           rescued_groups = rescued_groups_for(rescues)
           rescued_groups.zip(rescues).each do |group, res|

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

@@ -12,9 +12,12 @@ module RuboCop
       # 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
+      #   ----
       #
       # @example
       #
@@ -64,12 +67,40 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
-          variable_node = variable.scope.node.parent
-          return false unless variable_node.conditional?
+          variable_node = variable_node(variable)
+          return false unless node_or_its_ascendant_conditional?(variable_node)
 
-          outer_local_variable_node = outer_local_variable.scope.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.conditional?
+          return true if variable_node == outer_local_variable_node
 
-          outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
+          outer_local_variable_node.if_type? &&
+            variable_node == outer_local_variable_node.else_branch
+        end
+
+        def variable_node(variable)
+          parent_node = variable.scope.node.parent
+
+          if parent_node.when_type?
+            parent_node.parent
+          else
+            parent_node
+          end
+        end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          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

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

@@ -22,8 +22,8 @@ module RuboCop
       #   g.count #=> 2
       #
       class StructNewOverride < Base
-        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
-              ' and it may be unexpected.'
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s` ' \
+              'and it may be unexpected.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         STRUCT_METHOD_NAMES = Struct.instance_methods
@@ -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).first
-          return unless ancestor
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).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
 

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