rubocop 1.71.2 → 1.74.0

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

@@ -0,0 +1,258 @@
+# 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`).
+      #
+      # @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
+      #   inspect.to_s
+      #
+      #   # good
+      #   inspect
+      #
+      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] }.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/return_in_void_context.rb

@@ -35,22 +35,15 @@ module RuboCop
         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(:def).first
+          return unless def_node&.void_context?
+          return if return_node.each_ancestor(:any_block).any?(&:lambda?)
 
           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/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_in_number_conversion.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for cases where exceptions unrelated to the numeric constructors `Integer()`,
+      # `Float()`, `BigDecimal()`, `Complex()`, and `Rational()` may be unintentionally swallowed.
+      #
+      # @safety
+      #   The cop is unsafe for autocorrection because unexpected errors occurring in the argument
+      #   passed to numeric constructor (e.g., `Integer()`) can lead to incompatible behavior.
+      #   For example, changing it to `Integer(potential_exception_method_call, exception: false)`
+      #   ensures that exceptions raised by `potential_exception_method_call` are not ignored.
+      #
+      #   [source,ruby]
+      #   ----
+      #   Integer(potential_exception_method_call) rescue nil
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Integer(arg) rescue nil
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   Integer(arg, exception: false)
+      #
+      class SuppressedExceptionInNumberConversion < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        EXPECTED_EXCEPTION_CLASSES = %w[ArgumentError TypeError ::ArgumentError ::TypeError].freeze
+
+        # @!method numeric_constructor_rescue_nil(node)
+        def_node_matcher :numeric_constructor_rescue_nil, <<~PATTERN
+          (rescue
+            $#numeric_method?
+            (resbody nil? nil? (nil)) nil?)
+        PATTERN
+
+        # @!method begin_numeric_constructor_rescue_nil(node)
+        def_node_matcher :begin_numeric_constructor_rescue_nil, <<~PATTERN
+          (kwbegin
+            (rescue
+              $#numeric_method?
+              (resbody $_? nil?
+                {(nil) nil?}) nil?))
+        PATTERN
+
+        # @!method numeric_method?(node)
+        def_node_matcher :numeric_method?, <<~PATTERN
+          {
+            (call #constructor_receiver? {:Integer :BigDecimal :Complex :Rational}
+              _ _?)
+            (call #constructor_receiver? :Float
+              _)
+          }
+        PATTERN
+
+        # @!method constructor_receiver?(node)
+        def_node_matcher :constructor_receiver?, <<~PATTERN
+          {nil? (const {nil? cbase} :Kernel)}
+        PATTERN
+
+        minimum_target_ruby_version 2.6
+
+        # rubocop:disable Metrics/AbcSize
+        def on_rescue(node)
+          if (method, exception_classes = begin_numeric_constructor_rescue_nil(node.parent))
+            return unless expected_exception_classes_only?(exception_classes)
+
+            node = node.parent
+          else
+            return unless (method = numeric_constructor_rescue_nil(node))
+          end
+
+          arguments = method.arguments.map(&:source) << 'exception: false'
+          prefer = "#{method.method_name}(#{arguments.join(', ')})"
+          prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def expected_exception_classes_only?(exception_classes)
+          return true unless (arguments = exception_classes.first)
+
+          (arguments.values.map(&:source) - EXPECTED_EXCEPTION_CLASSES).none?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        def on_casgn(node)
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+
+          add_offense(node)
+        end
+
+        private
+
+        def after_private_modifier?(left_siblings)
+          access_modifier_candidates = left_siblings.compact.select do |left_sibling|
+            left_sibling.respond_to?(:send_type?) && left_sibling.send_type?
+          end
+
+          access_modifier_candidates.any? do |candidate|
+            candidate.command?(:private) && candidate.arguments.none?
+          end
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end

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

@@ -125,9 +125,14 @@ module RuboCop
           check_nonmutating(expr)
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
           node = node.children.first while node.begin_type?
           return unless node.call_type? && OPERATORS.include?(node.method_name)
+          if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
+            return
+          end
+
           return if block && yield(node)
 
           add_offense(node.loc.selector,
@@ -135,6 +140,7 @@ module RuboCop
             autocorrect_void_op(corrector, node)
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_var(node)
           return unless node.variable? || node.const_type?

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -26,6 +26,13 @@ module RuboCop
           extend NodePattern::Macros
           include RuboCop::AST::Sexp
 
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
           # Plug into the calculator
           def initialize(node, discount_repeated_attributes: false)
             super(node)
@@ -114,13 +121,6 @@ module RuboCop
             calls.fetch(value) { yield [calls, value] }
           end
 
-          VAR_SETTER_TO_GETTER = {
-            lvasgn: :lvar,
-            ivasgn: :ivar,
-            cvasgn: :cvar,
-            gvasgn: :gvar
-          }.freeze
-
           # @returns `[receiver, method | nil]` for the given setter `node`
           # or `nil` if it is not a setter.
           def setter_to_getter(node)

data/lib/rubocop/cop/mixin/alignment.rb

@@ -5,10 +5,10 @@ module RuboCop
     # This module checks for nodes that should be aligned to the left or right.
     # This amount is determined by the instance variable @column_delta.
     module Alignment
-      private
-
       SPACE = ' '
 
+      private
+
       attr_reader :column_delta
 
       def configured_indentation_width

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -18,12 +18,12 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      def ignored_line?
+      def ignored_line?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `ignored_line?` is deprecated. Use `allowed_line?` instead.
         WARNING
 
-        allowed_line?
+        allowed_line?(line)
       end
 
       def matches_allowed_pattern?(line)
@@ -31,12 +31,12 @@ module RuboCop
       end
 
       # @deprecated Use matches_allowed_pattern? instead
-      def matches_ignored_pattern?
+      def matches_ignored_pattern?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
         WARNING
 
-        matches_allowed_pattern?
+        matches_allowed_pattern?(line)
       end
 
       def allowed_patterns

data/lib/rubocop/cop/mixin/check_single_line_suitability.rb

@@ -35,7 +35,7 @@ module RuboCop
         comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
 
         comment_line_numbers.any? do |comment_line_number|
-          comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          comment_line_number.between?(node.first_line, node.last_line)
         end
       end
 

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -82,7 +82,7 @@ module RuboCop
               next_sibling.source_range
           next_sibling.loc.line
         elsif (parent = node.parent)
-          if parent.loc.respond_to?(:end) && parent.loc.end
+          if parent.loc?(:end)
             parent.loc.end.line
           else
             parent.loc.line

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -11,6 +11,24 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -212,24 +230,6 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
-
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
-      end
     end
   end
   # rubocop:enable Metrics/ModuleLength