rubocop 1.69.2 → 1.75.4

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

@@ -3,15 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `raise` or `fail` statements which are
-      # raising `Exception` class.
+      # Checks for `raise` or `fail` statements which raise `Exception` or
+      # `Exception.new`. Use `StandardError` or a specific exception class instead.
       #
-      # You can specify a module name that will be an implicit namespace
-      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
-      # for namespaced `Exception` when a namespace is omitted. This option can
-      # prevent the false positive by specifying a namespace to be omitted for
-      # `Exception`. Alternatively, make `Exception` a fully qualified class
-      # name with an explicit namespace.
+      # If you have defined your own namespaced `Exception` class, it is possible
+      # to configure the cop to allow it by setting `AllowedImplicitNamespaces` to
+      # an array with the names of the namespaces to allow. By default, this is set to
+      # `['Gem']`, which allows `Gem::Exception` to be raised without an explicit namespace.
+      # If not allowed, a false positive may be registered if `raise Exception` is called
+      # within the namespace.
+      #
+      # Alternatively, use a fully qualified name with `raise`/`fail`
+      # (eg. `raise Namespace::Exception`).
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
@@ -20,15 +23,31 @@ module RuboCop
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
+      #   raise Exception.new('Error message here')
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #   raise MyError.new, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem'] (default)
+      #   # bad - `Foo` is not an allowed implicit namespace
+      #   module Foo
+      #     def self.foo
+      #       raise Exception # This is qualified to `Foo::Exception`.
+      #     end
+      #   end
       #
-      # @example AllowedImplicitNamespaces: ['Gem']
       #   # good
       #   module Gem
       #     def self.foo
-      #       raise Exception # This exception means `Gem::Exception`.
+      #       raise Exception # This is qualified to `Gem::Exception`.
+      #     end
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     def self.foo
+      #       raise Foo::Exception
       #     end
       #   end
       class RaiseException < Base

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result:

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

@@ -17,17 +17,12 @@ module RuboCop
       #   * 2.0+ ... `enumerator`
       #   * 2.1+ ... `thread`
       #   * 2.2+ ... Add `rational` and `complex` above
-      #   * 2.5+ ... Add `pp` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
       #   * 3.2+ ... `set`
       #
       # This cop target those features.
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
-      #   `NameError` can be encountered when another file uses `PP.pp`.
-      #
       # @example
       #   # bad
       #   require 'unloaded_feature'
@@ -42,10 +37,6 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
         RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
-        PRETTY_PRINT_METHODS = %i[
-          pretty_inspect pretty_print pretty_print_cycle
-          pretty_print_inspect pretty_print_instance_variables
-        ].freeze
 
         # @!method redundant_require_statement?(node)
         def_node_matcher :redundant_require_statement?, <<~PATTERN
@@ -53,11 +44,6 @@ module RuboCop
             (str #redundant_feature?))
         PATTERN
 
-        # @!method pp_const?(node)
-        def_node_matcher :pp_const?, <<~PATTERN
-          (const {nil? cbase} :PP)
-        PATTERN
-
         def on_send(node)
           return unless redundant_require_statement?(node)
 
@@ -81,18 +67,11 @@ module RuboCop
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
-            (target_ruby_version >= 2.5 && feature_name == 'pp' && !need_to_require_pp?) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
             (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        def need_to_require_pp?
-          processed_source.ast.each_descendant(:send).any? do |node|
-            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
-          end
-        end
       end
     end
   end

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

@@ -29,7 +29,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
-        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
@@ -42,7 +42,7 @@ module RuboCop
         def on_send(node)
           return if node.receiver
 
-          node.each_child_node(:send) do |child|
+          node.each_child_node(:call) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
+      #
+      # Specifically, these cases are detected for each conversion method:
+      #
+      # * `to_s` when called on a string literal, interpolated string, heredoc,
+      #   or with `String.new` or `String()`.
+      # * `to_sym` when called on a symbol literal or interpolated symbol.
+      # * `to_i` when called on an integer literal or with `Integer()`.
+      # * `to_f` when called on a float literal of with `Float()`.
+      # * `to_r` when called on a rational literal or with `Rational()`.
+      # * `to_c` when called on a complex literal of with `Complex()`.
+      # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
+      # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
+      # * `to_set` when called on `Set.new` or `Set[]`.
+      #
+      # 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` and
+      # `foo.to_json.to_s`).
+      #
+      # @example
+      #   # bad
+      #   "text".to_s
+      #   :sym.to_sym
+      #   42.to_i
+      #   8.5.to_f
+      #   12r.to_r
+      #   1i.to_c
+      #   [].to_a
+      #   {}.to_h
+      #   Set.new.to_set
+      #
+      #   # good
+      #   "text"
+      #   :sym
+      #   42
+      #   8.5
+      #   12r
+      #   1i
+      #   []
+      #   {}
+      #   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
+      #
+      #   # good
+      #   foo.to_s
+      #
+      #   # bad - chaining a conversion to a method that is expected to return the same type
+      #   foo.inspect.to_s
+      #   foo.to_json.to_s
+      #
+      #   # good
+      #   foo.inspect
+      #   foo.to_json
+      #
+      class RedundantTypeConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `%<method>s` detected.'
+
+        # Maps conversion methods to the node types for the literals of that type
+        LITERAL_NODE_TYPES = {
+          to_s: %i[str dstr],
+          to_sym: %i[sym dsym],
+          to_i: %i[int],
+          to_f: %i[float],
+          to_r: %i[rational],
+          to_c: %i[complex],
+          to_a: %i[array],
+          to_h: %i[hash],
+          to_set: [] # sets don't have a literal or node type
+        }.freeze
+
+        # Maps each conversion method to the pattern matcher for that type's constructors
+        # Not every type has a constructor, for instance Symbol.
+        CONSTRUCTOR_MAPPING = {
+          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?',
+          to_h: 'hash_constructor?',
+          to_set: 'set_constructor?'
+        }.freeze
+
+        # Methods that already are expected to return a given type, which makes a further
+        # conversion redundant.
+        TYPED_METHODS = { to_s: %i[inspect to_json] }.freeze
+
+        CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
+
+        private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
+
+        # @!method type_constructor?(node, type_symbol)
+        def_node_matcher :type_constructor?, <<~PATTERN
+          (send {nil? (const {cbase nil?} :Kernel)} %1 ...)
+        PATTERN
+
+        # @!method string_constructor?(node)
+        def_node_matcher :string_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :String) :new ...)
+            #type_constructor?(:String)
+          }
+        PATTERN
+
+        # @!method integer_constructor?(node)
+        def_node_matcher :integer_constructor?, <<~PATTERN
+          #type_constructor?(:Integer)
+        PATTERN
+
+        # @!method float_constructor?(node)
+        def_node_matcher :float_constructor?, <<~PATTERN
+          #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)
+        PATTERN
+
+        # @!method complex_constructor?(node)
+        def_node_matcher :complex_constructor?, <<~PATTERN
+          #type_constructor?(:Complex)
+        PATTERN
+
+        # @!method array_constructor?(node)
+        def_node_matcher :array_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Array) {:new :[]} ...)
+            #type_constructor?(:Array)
+          }
+        PATTERN
+
+        # @!method hash_constructor?(node)
+        def_node_matcher :hash_constructor?, <<~PATTERN
+          {
+            (block (send (const {cbase nil?} :Hash) :new) ...)
+            (send (const {cbase nil?} :Hash) {:new :[]} ...)
+            (send {nil? (const {cbase nil?} :Kernel)} :Hash ...)
+          }
+        PATTERN
+
+        # @!method set_constructor?(node)
+        def_node_matcher :set_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Set) {:new :[]} ...)
+          }
+        PATTERN
+
+        # @!method exception_false_keyword_argument?(node)
+        def_node_matcher :exception_false_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :exception) false))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          return if hash_or_set_with_block?(node)
+
+          receiver = find_receiver(node)
+          return unless literal_receiver?(node, receiver) ||
+                        constructor?(node, receiver) ||
+                        chained_conversion?(node, receiver) ||
+                        chained_to_typed_method?(node, receiver)
+
+          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))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
+
+        private
+
+        def hash_or_set_with_block?(node)
+          return false if !node.method?(:to_h) && !node.method?(:to_set)
+
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
+
+        def find_receiver(node)
+          receiver = node.receiver
+          return unless receiver
+
+          while receiver.begin_type?
+            break unless receiver.children.one?
+
+            receiver = receiver.children.first
+          end
+
+          receiver
+        end
+
+        def literal_receiver?(node, receiver)
+          return false unless receiver
+
+          receiver.type?(*LITERAL_NODE_TYPES[node.method_name])
+        end
+
+        def constructor?(node, receiver)
+          matcher = CONSTRUCTOR_MAPPING[node.method_name]
+          return false unless matcher
+
+          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)
+          return false unless receiver&.call_type?
+
+          receiver.method?(node.method_name)
+        end
+
+        def chained_to_typed_method?(node, receiver)
+          return false unless receiver&.call_type?
+
+          TYPED_METHODS.fetch(node.method_name, []).include?(receiver.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the `Exception` class.
       #
       # @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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $({block numblock} (csend ...) ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
           }
         PATTERN
 
@@ -97,12 +97,19 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
+          return true if operator_inside_hash?(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
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
       end
     end
   end

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

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

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

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

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

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