rubocop 1.72.1 → 1.81.7

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_r`, `to_c`,
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_d`, `to_r`, `to_c`,
       # `to_a`, `to_h`, and `to_set`.
       #
       # When one of these methods is called on an object of the same type, that object
       # is returned, making the call unnecessary. The cop detects conversion methods called
       # on object literals, class constructors, class `[]` methods, and the `Kernel` methods
-      # `String()`, `Integer()`, `Float()`, `Rational()`, `Complex()` and `Array()`.
+      # `String()`, `Integer()`, `Float()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
       #
       # Specifically, these cases are detected for each conversion method:
       #
@@ -27,7 +27,8 @@ module RuboCop
       # In all cases, chaining one same `to_*` conversion methods listed above is redundant.
       #
       # The cop can also register an offense for chaining conversion methods on methods that are
-      # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s`).
+      # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and
+      # `foo.to_json.to_s`).
       #
       # @example
       #   # bad
@@ -39,7 +40,7 @@ module RuboCop
       #   1i.to_c
       #   [].to_a
       #   {}.to_h
-      #   Set.new.to_s
+      #   Set.new.to_set
       #
       #   # good
       #   "text"
@@ -52,6 +53,16 @@ module RuboCop
       #   {}
       #   Set.new
       #
+      #   # bad
+      #   Integer(var).to_i
+      #
+      #   # good
+      #   Integer(var)
+      #
+      #   # good - chaining to a type constructor with exceptions suppressed
+      #   # in this case, `Integer()` could return `nil`
+      #   Integer(var, exception: false).to_i
+      #
       #   # bad - chaining the same conversion
       #   foo.to_s.to_s
       #
@@ -59,10 +70,12 @@ module RuboCop
       #   foo.to_s
       #
       #   # bad - chaining a conversion to a method that is expected to return the same type
-      #   inspect.to_s
+      #   foo.inspect.to_s
+      #   foo.to_json.to_s
       #
       #   # good
-      #   inspect
+      #   foo.inspect
+      #   foo.to_json
       #
       class RedundantTypeConversion < Base
         extend AutoCorrector
@@ -88,6 +101,7 @@ module RuboCop
           to_s: 'string_constructor?',
           to_i: 'integer_constructor?',
           to_f: 'float_constructor?',
+          to_d: 'bigdecimal_constructor?',
           to_r: 'rational_constructor?',
           to_c: 'complex_constructor?',
           to_a: 'array_constructor?',
@@ -97,10 +111,10 @@ module RuboCop
 
         # Methods that already are expected to return a given type, which makes a further
         # conversion redundant.
-        TYPED_METHODS = { to_s: %i[inspect] }.freeze
+        TYPED_METHODS = { to_s: %i[inspect to_json] }.freeze
 
         CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
-        RESTRICT_ON_SEND = CONVERSION_METHODS
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
 
         private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
 
@@ -127,6 +141,11 @@ module RuboCop
           #type_constructor?(:Float)
         PATTERN
 
+        # @!method bigdecimal_constructor?(node)
+        def_node_matcher :bigdecimal_constructor?, <<~PATTERN
+          #type_constructor?(:BigDecimal)
+        PATTERN
+
         # @!method rational_constructor?(node)
         def_node_matcher :rational_constructor?, <<~PATTERN
           #type_constructor?(:Rational)
@@ -161,9 +180,14 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # @!method exception_false_keyword_argument?(node)
+        def_node_matcher :exception_false_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :exception) false))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
-          return if hash_or_set_with_block?(node)
+          return if node.arguments.any? || hash_or_set_with_block?(node)
 
           receiver = find_receiver(node)
           return unless literal_receiver?(node, receiver) ||
@@ -174,10 +198,10 @@ module RuboCop
           message = format(MSG, method: node.method_name)
 
           add_offense(node.loc.selector, message: message) do |corrector|
-            corrector.remove(node.loc.dot.join(node.loc.selector))
+            corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private
@@ -211,7 +235,13 @@ module RuboCop
           matcher = CONSTRUCTOR_MAPPING[node.method_name]
           return false unless matcher
 
-          public_send(matcher, receiver)
+          public_send(matcher, receiver) && !constructor_suppresses_exceptions?(receiver)
+        end
+
+        def constructor_suppresses_exceptions?(receiver)
+          # If the constructor suppresses exceptions with `exception: false`, it is possible
+          # it could return `nil`, and therefore a chained conversion is not redundant.
+          receiver.arguments.any? { |arg| exception_false_keyword_argument?(arg) }
         end
 
         def chained_conversion?(node, receiver)

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

@@ -53,6 +53,7 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -64,6 +65,8 @@ module RuboCop
               (args (arg _)) ...)
             (numblock
               $(call _ {:each_with_index :with_index} ...) 1 ...)
+            (itblock
+              $(call _ {:each_with_index :with_index} ...) _ ...)
           }
         PATTERN
 

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

@@ -49,6 +49,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -59,6 +60,8 @@ module RuboCop
               $(call _ {:each_with_object :with_object} _) (args (arg _)) ...)
             (numblock
               $(call _ {:each_with_object :with_object} _) 1 ...)
+            (itblock
+              $(call _ {:each_with_object :with_object} _) _ ...)
           }
         PATTERN
 

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

@@ -43,7 +43,7 @@ module RuboCop
         def on_irange(node)
           return if node.parent&.begin_type?
           return unless node.begin && node.end
-          return if same_line?(node.begin, node.end)
+          return if same_line?(node.loc.operator, node.end)
 
           message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
 

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

@@ -24,10 +24,7 @@ module RuboCop
         MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
-          return unless node.children.first
-
-          rescue_args = node.children.first.children
-          return unless rescue_args.any? { |a| targets_exception?(a) }
+          return unless node.exceptions.any? { |exception| targets_exception?(exception) }
 
           add_offense(node)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check for arguments to `rescue` that will result in a `TypeError`
+      # Checks for arguments to `rescue` that will result in a `TypeError`
       # if an exception is raised.
       #
       # @example

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

@@ -32,25 +32,23 @@ module RuboCop
       class ReturnInVoidContext < Base
         MSG = 'Do not return a value in `%<method>s`.'
 
+        # Returning out of these methods only exits the block itself.
+        SCOPE_CHANGING_METHODS = %i[lambda define_method define_singleton_method].freeze
+
         def on_return(return_node)
           return unless return_node.descendants.any?
 
-          context_node = non_void_context(return_node)
-
-          return unless context_node&.def_type?
-          return unless context_node&.void_context?
+          def_node = return_node.each_ancestor(:any_def).first
+          return unless def_node&.void_context?
+          return if return_node.each_ancestor(:any_block).any? do |block_node|
+            SCOPE_CHANGING_METHODS.include?(block_node.method_name)
+          end
 
           add_offense(
             return_node.loc.keyword,
-            message: format(message, method: context_node.method_name)
+            message: format(message, method: def_node.method_name)
           )
         end
-
-        private
-
-        def non_void_context(return_node)
-          return_node.each_ancestor(:block, :def, :defs).first
-        end
       end
     end
   end

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

@@ -97,7 +97,7 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
-          return true if operator_inside_hash?(send_node)
+          return true if operator_inside_collection_literal?(send_node)
           return false unless send_node.comparison_method?
           return false unless (node = send_node.parent)
 
@@ -105,10 +105,10 @@ module RuboCop
             (node.respond_to?(:comparison_method?) && node.comparison_method?)
         end
 
-        def operator_inside_hash?(send_node)
-          # If an operator call (without a dot) is inside a hash, it needs
+        def operator_inside_collection_literal?(send_node)
+          # If an operator call (without a dot) is inside an array or a hash, it needs
           # to be parenthesized when converted to safe navigation.
-          send_node.parent&.pair_type? && !send_node.loc.dot
+          send_node.parent&.type?(:array, :pair) && !send_node.loc.dot
         end
       end
     end

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

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

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

@@ -125,13 +125,13 @@ module RuboCop
             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)
+            conditional_assignment =
+              conditional_assignment?(assignment_node.parent, argument.scope.node)
 
             unless uses_var?(assignment_node, argument.name)
               # It's impossible to decide whether a branch or block is executed,
               # so the precise reassignment location is undecidable.
-              next false if node_within_block_or_conditional
+              next false if conditional_assignment
 
               yield(assignment.node, location_known)
               break
@@ -147,13 +147,13 @@ module RuboCop
           node.source_range.begin_pos
         end
 
-        # Check whether the given node is nested into block or conditional.
+        # Check whether the given node is always executed or not
         #
-        def node_within_block_or_conditional?(node, stop_search_node)
+        def conditional_assignment?(node, stop_search_node)
           return false if node == stop_search_node
 
-          node.conditional? || node.block_type? ||
-            node_within_block_or_conditional?(node.parent, stop_search_node)
+          node.conditional? || node.type?(:block, :rescue) ||
+            conditional_assignment?(node.parent, stop_search_node)
         end
 
         # Get argument references without assignments' references

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

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

@@ -51,7 +51,18 @@ module RuboCop
 
         # @!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)})
+          {
+            (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)

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

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

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

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

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

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

data/lib/rubocop/cop/lint/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

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

@@ -43,6 +43,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def after_block(node)
           @instance_eval_count -= 1 if instance_eval_block?(node)

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

@@ -101,9 +101,8 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
-        def on_numblock(node)
-          check(node) if loop_method?(node)
-        end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -189,8 +188,9 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
-            # Numblocks have the arguments count as a number in the AST.
-            next if sibling.is_a?(Integer)
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -17,6 +17,7 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
+      #   URI.encode_uri_component(uri) # Since Ruby 3.1
       #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
       #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
@@ -27,6 +28,7 @@ module RuboCop
       #
       #   # good
       #   CGI.unescape(enc_uri)
+      #   URI.decode_uri_component(uri) # Since Ruby 3.1
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
       class UriEscapeUnescape < Base

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

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

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

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