rubocop 1.67.0 → 1.75.5

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

@@ -78,7 +78,7 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if node.receiver.str_type? || node.receiver.sym_type?
+          if node.receiver.type?(:str, :sym)
             register_offense(node, correction: node.receiver.value.to_sym.inspect)
           elsif node.receiver.dstr_type?
             register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")

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

@@ -6,9 +6,12 @@ module RuboCop
       # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-          processed_source.diagnostics.each do |diagnostic|
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
             add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # that contain unescaped `]` characters.
+      #
+      # It emulates the following Ruby warning:
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '/abc]123/'
+      # -e:1: warning: regular expression has ']' without escape: /abc]123/
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /abc]123/
+      #   %r{abc]123}
+      #   Regexp.new('abc]123')
+      #   Regexp.compile('abc]123')
+      #
+      #   # good
+      #   /abc\]123/
+      #   %r{abc\]123}
+      #   Regexp.new('abc\]123')
+      #   Regexp.compile('abc\]123')
+      #
+      class UnescapedBracketInRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Regular expression has `]` without escape.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method regexp_constructor(node)
+        def_node_search :regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            $str
+            ...
+          )
+        PATTERN
+
+        def on_regexp(node)
+          RuboCop::Util.silence_warnings do
+            node.parsed_tree&.each_expression do |expr|
+              detect_offenses(node, expr)
+            end
+          end
+        end
+
+        def on_send(node)
+          # Ignore nodes that contain interpolation
+          return if node.each_descendant(:dstr).any?
+
+          regexp_constructor(node) do |text|
+            parse_regexp(text.value)&.each_expression do |expr|
+              detect_offenses(text, expr)
+            end
+          end
+        end
+
+        private
+
+        def detect_offenses(node, expr)
+          return unless expr.type?(:literal)
+
+          expr.text.scan(/(?<!\\)\]/) do
+            pos = Regexp.last_match.begin(0)
+            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+
+            location = range_at_index(node, expr.ts, pos)
+
+            add_offense(location) do |corrector|
+              corrector.replace(location, '\]')
+            end
+          end
+        end
+
+        def range_at_index(node, index, offset)
+          adjustment = index + offset
+          node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
+        end
+      end
+    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
@@ -81,7 +83,7 @@ module RuboCop
           node.arguments.count do |arg|
             return Float::INFINITY if arg.restarg_type?
 
-            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+            arg.type?(:arg, :optarg, :mlhs)
           end
         end
       end

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

@@ -130,7 +130,7 @@ module RuboCop
 
           block_body_node.each_descendant(:next, :break) do |n|
             # Ignore `next`/`break` inside an inner block
-            next if n.each_ancestor(:block).first != block_body_node.parent
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
             next unless n.first_argument
 
             nodes << n.first_argument

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

@@ -32,6 +32,23 @@ module RuboCop
       class UnreachableCode < Base
         MSG = 'Unreachable code detected.'
 
+        def initialize(config = nil, options = nil)
+          super
+          @redefined = []
+          @instance_eval_count = 0
+        end
+
+        def on_block(node)
+          @instance_eval_count += 1 if instance_eval_block?(node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def after_block(node)
+          @instance_eval_count -= 1 if instance_eval_block?(node)
+        end
+
         def on_begin(node)
           expressions = *node
 
@@ -46,19 +63,23 @@ module RuboCop
 
         private
 
+        def redefinable_flow_method?(method)
+          %i[raise fail throw exit exit! abort].include? method
+        end
+
         # @!method flow_command?(node)
         def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
             (send
              {nil? (const {nil? cbase} :Kernel)}
-             {:raise :fail :throw :exit :exit! :abort}
+             #redefinable_flow_method?
              ...)
           }
         PATTERN
 
         def flow_expression?(node)
-          return true if flow_command?(node)
+          return report_on_flow_command?(node) if flow_command?(node)
 
           case node.type
           when :begin, :kwbegin
@@ -68,6 +89,8 @@ module RuboCop
             check_if(node)
           when :case, :case_match
             check_case(node)
+          when :def
+            register_redefinition(node)
           else
             false
           end
@@ -88,6 +111,33 @@ module RuboCop
 
           branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
+
+        def register_redefinition(node)
+          @redefined << node.method_name if redefinable_flow_method? node.method_name
+          false
+        end
+
+        def instance_eval_block?(node)
+          node.any_block_type? && node.method?(:instance_eval)
+        end
+
+        def report_on_flow_command?(node)
+          return true unless node.send_type?
+
+          # By the contract of this function, this case means that
+          # the method is called on `Kernel` in which case we
+          # always want to report a warning.
+          return true if node.receiver
+
+          # Inside an `instance_eval` we have no way to tell the
+          # type of `self` just by looking at the AST, so we can't
+          # tell if the give function that's called has been
+          # redefined or not, so to avoid false positives, we silence
+          # the warning.
+          return false if @instance_eval_count.positive?
+
+          !@redefined.include? node.method_name
+        end
       end
     end
   end

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

@@ -101,14 +101,13 @@ 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
 
         def loop_method?(node)
-          return false unless node.block_type? || node.numblock_type?
+          return false unless node.any_block_type?
 
           send_node = node.send_node
           loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
@@ -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/unused_method_argument.rb

@@ -39,6 +39,8 @@ module RuboCop
       #   end
       #
       # @example IgnoreNotImplementedMethods: true (default)
+      #   # with default value of `NotImplementedExceptions: ['NotImplementedError']`
+      #
       #   # good
       #   def do_something(unused)
       #     raise NotImplementedError
@@ -48,6 +50,14 @@ module RuboCop
       #     fail "TODO"
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true
+      #   # with `NotImplementedExceptions: ['AbstractMethodError']`
+      #
+      #   # good
+      #   def do_something(unused)
+      #     raise AbstractMethodError
+      #   end
+      #
       # @example IgnoreNotImplementedMethods: false
       #   # bad
       #   def do_something(unused)
@@ -57,14 +67,13 @@ module RuboCop
       #   def do_something_else(unused)
       #     fail "TODO"
       #   end
-      #
       class UnusedMethodArgument < Base
         include UnusedArgument
         extend AutoCorrector
 
         # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError) ...)
+          {(send nil? :raise #allowed_exception_class? ...)
            (send nil? :fail ...)}
         PATTERN
 
@@ -115,6 +124,13 @@ module RuboCop
 
           message
         end
+
+        def allowed_exception_class?(node)
+          return false unless node.const_type?
+
+          allowed_class_names = Array(cop_config.fetch('NotImplementedExceptions', []))
+          allowed_class_names.include?(node.const_name)
+        end
       end
     end
   end

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

@@ -143,6 +143,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -159,12 +160,12 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
+          (any_block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -268,7 +269,7 @@ module RuboCop
         end
 
         def start_of_new_scope?(child)
-          child.module_type? || child.class_type? || child.sclass_type? || eval_call?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
         end
 
         def eval_call?(child)
@@ -282,7 +283,7 @@ module RuboCop
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
+                (any_block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -17,7 +17,7 @@ module RuboCop
       # rescue, ensure, etc.
       #
       # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
-      # operator assignment can cause NameError if this assignment has been used to declare
+      # operator assignment can cause `NameError` if this assignment has been used to declare
       # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
       # "undefined local variable or method `a' for main:Object (NameError)".
       #

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to `defined?` with strings or symbols as the argument.
+      # Such calls will always return `'expression'`, you probably meant to
+      # check for the existence of a constant, method, or variable instead.
+      #
+      # `defined?` is part of the Ruby syntax and doesn't behave like normal methods.
+      # You can safely pass in what you are checking for directly, without encountering
+      # a `NameError`.
+      #
+      # When interpolation is used, oftentimes it is not possible to write the
+      # code with `defined?`. In these cases, switch to one of the more specific methods:
+      #
+      # * `class_variable_defined?`
+      # * `const_defined?`
+      # * `method_defined?`
+      # * `instance_variable_defined?`
+      # * `binding.local_variable_defined?`
+      #
+      # @example
+      #
+      #   # bad
+      #   defined?('FooBar')
+      #   defined?(:FooBar)
+      #   defined?(:foo_bar)
+      #   defined?('foo_bar')
+      #
+      #   # good
+      #   defined?(FooBar)
+      #   defined?(foo_bar)
+      #
+      #   # bad - interpolation
+      #   bar = 'Bar'
+      #   defined?("Foo::#{bar}::Baz")
+      #
+      #   # good
+      #   bar = 'Bar'
+      #   defined?(Foo) && Foo.const_defined?(bar) && Foo.const_get(bar).const_defined?(:Baz)
+      class UselessDefined < Base
+        MSG = 'Calling `defined?` with a %<type>s argument will always return a truthy value.'
+        TYPES = { str: 'string', dstr: 'string', sym: 'symbol', dsym: 'symbol' }.freeze
+
+        def on_defined?(node)
+          # NOTE: `defined?` always takes one argument. Anything else is a syntax error.
+          return unless (type = TYPES[node.first_argument.type])
+
+          add_offense(node, message: format(MSG, type: type))
+        end
+      end
+    end
+  end
+end

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

@@ -25,8 +25,12 @@ module RuboCop
       #     do_something_else
       #   end
       class UselessElseWithoutRescue < Base
+        extend TargetRubyVersion
+
         MSG = '`else` without `rescue` is useless.'
 
+        maximum_target_ruby_version 2.5
+
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
             next unless diagnostic.reason == :useless_else

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -35,7 +35,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(send (send nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
 
         # @!method useless_abbreviated_assignment?(node)
         def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
@@ -50,6 +50,7 @@ module RuboCop
             corrector.replace(node, variable)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
           return unless useless_abbreviated_assignment?(node)