rubocop 1.89.0 → 1.90.0

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `super` calls with explicit arguments that pass the wrong
+      # number of positional arguments to the overridden implementation, using
+      # the project index.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only `super` inside a plain instance method defined directly in a class
+      # body is considered, and only when the enclosing class resolves in the
+      # index and its entire ancestry is resolved, so a superclass method coming
+      # from a gem, the standard library, or a dynamic definition never produces
+      # an offense. The overridden implementation is the first ancestor after
+      # the enclosing class in the index's method resolution order that defines
+      # the method; when it is not a plain method definition (an `attr_*` or an
+      # alias) or its definitions disagree on arity, the call is not checked.
+      # Calls that forward arguments (`*`, `**`, `...`) are skipped, and bare
+      # `super` (which forwards the current method's parameters) is not checked.
+      # Methods the index attributes to `Object`, `Kernel`, or `BasicObject`
+      # are never used as the overridden implementation, since a `def` inside
+      # a block at the top level (`Struct.new do ... end`) is indexed under
+      # `Object` even though it defines a method somewhere else entirely.
+      #
+      # @example
+      #   # Given the project defines:
+      #   #   class Base
+      #   #     def initialize(name, size); end
+      #   #   end
+      #
+      #   # bad
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name, 0)
+      #     end
+      #   end
+      #
+      class SuperArgumentMismatch < Base
+        include ProjectIndexHelp
+        include IndexedMethodArity
+
+        MSG = 'Wrong number of arguments to `super` ' \
+              '(given %<given>d, expected %<expected>s for `%<parent>s#%<method>s`).'
+
+        # Blocks that change what method (or scope) `super` refers to, or in
+        # which `super` is not statically resolvable.
+        CONTEXT_CHANGING_BLOCKS = %i[
+          define_method define_singleton_method class_eval class_exec
+          module_eval module_exec instance_eval instance_exec refine
+        ].freeze
+
+        # Methods the index attributes to the root namespaces are not
+        # trustworthy super targets: a `def` inside a block at the top level
+        # (`Struct.new do ... end`, `Class.new do ... end`) is indexed under
+        # `Object` even though it defines a method somewhere else entirely.
+        BUILTIN_ROOTS = %w[Object Kernel BasicObject].freeze
+
+        def on_super(node)
+          return unless project_index
+
+          def_node = enclosing_instance_method(node)
+          return unless def_node
+
+          shape, parent = resolved_super_shape(def_node)
+          return unless shape
+
+          min, max, has_keywords = shape
+          given = positional_argument_count(node, has_keywords)
+          return if given.nil? || arity_satisfied?(given, min, max)
+
+          add_offense(node.loc.keyword,
+                      message: message(def_node.method_name, parent, given, min, max))
+        end
+
+        private
+
+        def message(method_name, parent, given, min, max)
+          format(MSG, given: given, expected: expected_range(min, max),
+                      parent: parent.name, method: method_name)
+        end
+
+        # The `def` node whose method the `super` call re-dispatches, or nil
+        # when the context is not statically known: `super` inside a
+        # singleton method, inside `define_method` or an eval/refine block,
+        # or outside any method.
+        def enclosing_instance_method(node)
+          node.each_ancestor(:any_def, :any_block, :sclass).each do |ancestor|
+            case ancestor.type
+            when :def then return ancestor
+            when :defs, :sclass then return nil
+            else
+              return nil if CONTEXT_CHANGING_BLOCKS.include?(ancestor.method_name)
+            end
+          end
+
+          nil
+        end
+
+        # `[[min, max, has_keywords], parent]` for the implementation `super`
+        # dispatches to, or nil when the enclosing class or the overridden
+        # method is not statically known.
+        def resolved_super_shape(def_node)
+          declaration = enclosing_class_declaration(def_node)
+          return nil unless declaration
+          return nil unless fully_resolved_index_ancestry?(declaration, ignore_extend: true)
+
+          super_method_shape(declaration, def_node.method_name)
+        rescue StandardError
+          nil
+        end
+
+        # The index declaration of the class whose body directly contains
+        # `def_node`, or nil when the method is not defined directly in a
+        # class body (module methods are excluded because their `super`
+        # target depends on where the module is mixed in) or the class does
+        # not resolve in the index.
+        def enclosing_class_declaration(def_node)
+          class_node = def_node.each_ancestor(:class, :module, :sclass, :any_block).first
+          return nil unless class_node&.class_type?
+
+          declaration = project_index[lexical_nesting_of(def_node).join('::')]
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil unless declared_at?(declaration, class_node)
+
+          declaration
+        end
+
+        # Whether one of the declaration's definitions is the given class
+        # node, anchoring the name-based lookup to the source being
+        # inspected (a qualified identifier like `class Foo::Bar` can
+        # resolve to a namespace other than the joined nesting names).
+        def declared_at?(declaration, class_node)
+          declaration.definitions.any? do |definition|
+            location = definition.location
+            location.uri.start_with?(FILE_URI_PREFIX) &&
+              location.to_display.start_line == class_node.first_line &&
+              same_file?(location.to_file_path, processed_source.file_path)
+          end
+        end
+
+        # The shape of the first implementation of `method_name` after the
+        # enclosing class in the index's method resolution order, or nil
+        # when no indexed ancestor defines it (e.g. it comes from a gem or
+        # the standard library, which are not indexed).
+        def super_method_shape(declaration, method_name)
+          ancestors = declaration.ancestors.to_a
+          position = ancestors.index { |ancestor| ancestor.name == declaration.name }
+          return nil unless position
+
+          ancestors.drop(position + 1).each do |ancestor|
+            return nil if BUILTIN_ROOTS.include?(ancestor.name)
+
+            member = ancestor.member("#{method_name}()")
+            next unless member
+
+            # The first definer along the chain is the receiving
+            # implementation; when its shape is unknown there is nothing
+            # further to check.
+            shape = indexed_member_shape(member)
+            return shape && [shape, ancestor]
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -78,7 +78,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next 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)
@@ -100,7 +100,6 @@ module RuboCop
             corrector.replace(node, prefer)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -135,7 +135,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -157,7 +157,6 @@ module RuboCop
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def keyword_hash_argument?(send_arg)
           send_arg.hash_type? && !send_arg.braces?

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

@@ -83,7 +83,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -102,7 +102,6 @@ module RuboCop
             false
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def check_if(node)
           if_branch = node.if_branch

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

@@ -14,10 +14,17 @@ module RuboCop
       # in the indexed project (regardless of the receiver), when it is the source
       # of an `alias`, or when its name appears in the same file as a symbol or
       # inside a string literal (covering `send(:name)` and declarative DSLs like
-      # `before_action :name`). Methods defined in classes or modules with
-      # descendants are not checked, since they may be invoked through `super`
-      # or inherited dispatch, and neither are methods whose names are built
-      # dynamically (e.g. `send("do_#{action}")`).
+      # `before_action :name`). An interpolated symbol or string with a literal
+      # prefix (e.g. `send(:"format_#{type}")`) counts as a reference to every
+      # method whose name starts with that prefix; fully dynamic names cannot
+      # be detected. Methods defined in classes or modules with descendants are
+      # not checked, since they may be invoked through `super` or inherited
+      # dispatch.
+      #
+      # Methods whose names are composed by a framework (e.g. Rails
+      # `attribute_method_suffix` generating `attribute?` methods) can be
+      # excluded from the check with `AllowedNames` (exact names) or
+      # `AllowedPatterns` (regular expressions).
       #
       # The cop is disabled by default because symbol-based references from
       # *other* files (e.g. a Rails callback declared in a concern) cannot be
@@ -49,28 +56,56 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowedNames: ['attribute?']
+      #   # good - the name is explicitly allowed
+      #   class Contact
+      #     private
+      #
+      #     def attribute?
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['_hook\z']
+      #   # good - the name matches an allowed pattern
+      #   class Service
+      #     private
+      #
+      #     def before_save_hook
+      #     end
+      #   end
+      #
       class UnusedPrivateMethod < Base
+        include AllowedPattern
         include ProjectIndexHelp
 
         MSG = 'Private method `%<method>s` appears to be unused.'
 
         IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!=]?/.freeze
+        NAME_PREFIX_PATTERN = /[a-zA-Z_]\w*\z/.freeze
 
         # Methods invoked implicitly by the Ruby runtime.
-        IMPLICITLY_INVOKED_METHODS = %i[initialize initialize_copy initialize_clone
-                                        initialize_dup method_missing respond_to_missing?
-                                        marshal_dump marshal_load].to_set.freeze
+        IMPLICITLY_INVOKED_METHODS = %i[
+          initialize initialize_copy initialize_clone initialize_dup
+          method_missing respond_to_missing? marshal_dump marshal_load
+          coerce instance_variables_to_inspect
+          inherited included extended prepended
+          append_features extend_object prepend_features
+          const_missing const_added
+          method_added method_removed method_undefined
+          singleton_method_added singleton_method_removed singleton_method_undefined
+        ].to_set.freeze
 
         class << self
-          # The reference-name set is derived once per index and shared by the
-          # per-file cop instances.
-          def reference_names_cache
-            @reference_names_cache ||= {}.compare_by_identity
-          end
+          # The reference-name set is a property of the index, not of the cop
+          # instance, so all per-file instances share one computation. A
+          # single-entry cache (instead of a hash keyed by index) avoids
+          # retaining stale graphs in long-lived processes.
+          attr_accessor :cached_reference_names
         end
 
         def on_new_investigation
           @literal_names = nil
+          @literal_name_prefixes = nil
           super
         end
 
@@ -90,6 +125,7 @@ module RuboCop
 
         def checkable_declaration(node)
           return nil if IMPLICITLY_INVOKED_METHODS.include?(node.method_name)
+          return nil if allowed_name?(node.method_name)
           return nil if node.each_ancestor(:any_def, :any_block, :sclass).any?
           return nil unless (namespace_node = node.each_ancestor(:class, :module).first)
 
@@ -97,6 +133,12 @@ module RuboCop
           declaration if declaration&.private?
         end
 
+        def allowed_name?(method_name)
+          name = method_name.to_s
+
+          cop_config.fetch('AllowedNames', []).include?(name) || matches_allowed_pattern?(name)
+        end
+
         def method_declaration(node, namespace_node)
           namespace = resolve_constant_in_index(namespace_node.identifier)
           return nil unless namespace.is_a?(Rubydex::Namespace)
@@ -107,13 +149,22 @@ module RuboCop
         def referenced?(method_name)
           name = method_name.to_s
 
-          referenced_names.include?(name) || literal_names.include?(name)
+          referenced_names.include?(name) || literal_names.include?(name) ||
+            literal_name_prefixes.any? { |prefix| name.start_with?(prefix) }
         end
 
         def referenced_names
-          self.class.reference_names_cache[project_index] ||=
-            project_index.method_references
-                         .to_set { |reference| reference.name.delete_suffix('()') }
+          index, names = self.class.cached_reference_names
+          return names if index.equal?(project_index)
+
+          compute_referenced_names.tap do |computed|
+            self.class.cached_reference_names = [project_index, computed]
+          end
+        end
+
+        def compute_referenced_names
+          project_index.method_references
+                       .to_set { |reference| reference.name.delete_suffix('()') }
         end
 
         # Symbol literals and identifier-like tokens inside string literals in the
@@ -127,11 +178,37 @@ module RuboCop
               if literal.sym_type?
                 names << literal.value.to_s
               else
-                literal.value.scan(IDENTIFIER_PATTERN) { |token| names << token }
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(IDENTIFIER_PATTERN) { |token| names << token }
               end
             end
         end
 
+        # The leading literal fragment of an interpolated symbol or string acts
+        # as a method-name prefix: `send(:"format_#{type}")` may invoke any
+        # method whose name starts with `format_`. Only the leading fragment
+        # qualifies (a mid-string fragment is not a name prefix), and a fully
+        # dynamic name contributes nothing.
+        def literal_name_prefixes
+          @literal_name_prefixes ||=
+            processed_source.ast.each_descendant(:dsym, :dstr)
+                            .with_object(Set.new) do |literal, prefixes|
+              prefix = interpolation_prefix(literal)
+              prefixes << prefix if prefix
+            end
+        end
+
+        def interpolation_prefix(node)
+          return nil if node.children.all?(&:str_type?)
+
+          leading_fragment = node.children.first
+          return nil unless leading_fragment&.str_type?
+
+          leading_fragment.value[NAME_PREFIX_PATTERN]
+        end
+
         # A method defined in a class or module with descendants may be invoked
         # through `super` or inherited dispatch, which the index does not track.
         def owner_with_descendants?(declaration)

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

@@ -210,7 +210,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
@@ -228,7 +228,6 @@ module RuboCop
 
           [cur_vis, unused]
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?

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

@@ -173,7 +173,7 @@ module RuboCop
           node.receiver.nil? && !node.arguments?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, assignment)
           if assignment.exception_assignment?
             remove_exception_assignment_part(corrector, assignment.node)
@@ -189,7 +189,6 @@ module RuboCop
             remove_local_variable_assignment_part(corrector, assignment.node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def remove_exception_assignment_part(corrector, node)
           range = node.parent.children.first&.source_range || node.parent.location.keyword

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

@@ -10,6 +10,11 @@ module RuboCop
       # It does not support autocorrection due to behavior change and multiple ways to fix it.
       # Or a public constant may be intended.
       #
+      # Constant assignments that define classes or modules via `Class.new`, `Module.new`,
+      # `Struct.new`, or `Data.define` are allowed. Those forms are class and module definitions
+      # written with assignment syntax, and match the common practice of placing nested
+      # `class` / `module` bodies after `private` without intending private constant visibility.
+      #
       # @example
       #
       #   # bad
@@ -29,6 +34,19 @@ module RuboCop
       #     PUBLIC_CONST = 42 # If private scope is not intended.
       #   end
       #
+      #   # good - class/module definitions via assignment, same as nested `class`/`module`
+      #   class Foo
+      #     private
+      #
+      #     def some_private_method
+      #     end
+      #
+      #     MyClass = Class.new
+      #     MyModule = Module.new
+      #     MyStruct = Struct.new(:name)
+      #     MyData = Data.define(:name)
+      #   end
+      #
       class UselessConstantScoping < Base
         MSG = 'Useless `private` access modifier for constant scope.'
 
@@ -37,9 +55,27 @@ module RuboCop
           (send nil? :private_constant $...)
         PATTERN
 
+        # Matches class/module-like constant assignments. Nested `class` / `module`
+        # keyword definitions are not visited by this cop; these assignment forms are
+        # the equivalent syntax and should be treated the same way.
+        # @!method class_or_module_definition_assignment?(node)
+        def_node_matcher :class_or_module_definition_assignment?, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (any_block
+              {
+                (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+                (send (const {nil? cbase} :Data) :define ...)
+              }
+              ...)
+          }
+        PATTERN
+
         def on_casgn(node)
           return unless after_private_modifier?(node.left_siblings)
           return if private_constantize?(node.right_siblings, node.name)
+          return if class_or_module_definition_assignment?(node.expression)
 
           add_offense(node)
         end

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.type?(:restarg, :optarg, :kwoptarg) }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg, :kwrestarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def only_reraising?(resbody_node)
           return false if use_exception_variable_in_ensure?(resbody_node)
 
@@ -70,7 +70,6 @@ module RuboCop
 
           exception_objects(resbody_node).include?(exception_name)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def use_exception_variable_in_ensure?(resbody_node)
           return false unless (exception_variable = resbody_node.exception_variable)

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -12,6 +12,8 @@ module RuboCop
             @receiver = receiver
             @additional_nil_methods = additional_nil_methods
             @checked_nodes = {}.compare_by_identity
+            @receiver_binding_name = binding_name(receiver)
+            @receiver_binding_scope = binding_scope(receiver) if @receiver_binding_name
           end
 
           def cant_be_nil?
@@ -20,7 +22,7 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics
+          # rubocop:disable-next Metrics
           def _cant_be_nil?(node, receiver)
             return false unless node
 
@@ -34,7 +36,9 @@ module RuboCop
             when :def, :defs, :class, :module, :sclass
               return false
             when :send
-              return non_nil_method?(node.method_name) if node.receiver == receiver
+              if node.receiver == receiver && same_binding_as_receiver?(node.receiver)
+                return non_nil_method?(node.method_name)
+              end
 
               node.arguments.each do |argument|
                 return true if _cant_be_nil?(argument, receiver)
@@ -74,13 +78,12 @@ module RuboCop
               false
             end
           end
-          # rubocop:enable Metrics
 
           def non_nil_method?(method_name)
             !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
           end
 
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           def sole_condition_of_parent_if?(node)
             child = node
             parent = node.parent
@@ -104,12 +107,63 @@ module RuboCop
 
             false
           end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
           def non_nil_condition?(condition, node)
-            return true if condition == node
+            return true if condition == node && same_binding_as_receiver?(condition)
+            return false unless condition.csend_type?
+
+            root_receiver = csend_root_receiver(condition)
+
+            root_receiver == node && same_binding_as_receiver?(root_receiver)
+          end
+
+          # Structurally equal occurrences can be different variables: `it` binds to
+          # its innermost block, and a block parameter can shadow an outer variable of
+          # the same name. Evidence about such a receiver only holds when both occurrences
+          # resolve to the same binding.
+          def same_binding_as_receiver?(occurrence)
+            return true unless @receiver_binding_name
+
+            binding_scope(occurrence).equal?(@receiver_binding_scope)
+          end
+
+          # The name whose binding can differ between structurally equal occurrences:
+          # a local variable (block parameters included), or a bare `it` call, which is
+          # how `it` parses when the target Ruby version is below 3.4 even though the code
+          # may run on 3.4+ where `it` is the implicit block parameter.
+          def binding_name(node)
+            if node.lvar_type?
+              node.children.first
+            elsif node.send_type? && !node.receiver && node.method?(:it) && node.arguments.empty?
+              :it
+            end
+          end
+
+          def binding_scope(occurrence)
+            node = occurrence
+
+            while (parent = node.parent)
+              case parent.type
+              when :block, :numblock, :itblock
+                # Only the body is inside the block's scope; the send node and the arguments of
+                # the block node evaluate in the outer scope.
+                return parent if parent.body.equal?(node) && block_binds_name?(parent)
+              when :def, :defs, :class, :module, :sclass
+                return parent
+              end
+
+              node = parent
+            end
+
+            nil
+          end
+
+          def block_binds_name?(block_node)
+            name = @receiver_binding_name
+
+            return true if block_node.argument_list.any? { |argument| argument.name == name }
 
-            condition.csend_type? && csend_root_receiver(condition) == node
+            name == :it && block_node.arguments.empty?
           end
 
           # Whether control reaches `node` by falling through its left siblings rather than by

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

@@ -153,7 +153,7 @@ module RuboCop
           check_expression(case_node.else_branch) if case_node.else_branch
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next 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)
@@ -168,7 +168,6 @@ 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/lint.rb

@@ -13,6 +13,7 @@ module RuboCop
       register_cop :AmbiguousOperatorPrecedence, "#{__dir__}/lint/ambiguous_operator_precedence"
       register_cop :AmbiguousRange, "#{__dir__}/lint/ambiguous_range"
       register_cop :AmbiguousRegexpLiteral, "#{__dir__}/lint/ambiguous_regexp_literal"
+      register_cop :ArgumentMismatch, "#{__dir__}/lint/argument_mismatch"
       register_cop :ArrayLiteralInRegexp, "#{__dir__}/lint/array_literal_in_regexp"
       register_cop :AssignmentInCondition, "#{__dir__}/lint/assignment_in_condition"
       register_cop :BigDecimalNew, "#{__dir__}/lint/big_decimal_new"
@@ -128,6 +129,7 @@ module RuboCop
       register_cop :ShadowedException, "#{__dir__}/lint/shadowed_exception"
       register_cop :ShadowingOuterLocalVariable, "#{__dir__}/lint/shadowing_outer_local_variable"
       register_cop :StructNewOverride, "#{__dir__}/lint/struct_new_override"
+      register_cop :SuperArgumentMismatch, "#{__dir__}/lint/super_argument_mismatch"
       register_cop :SuppressedException, "#{__dir__}/lint/suppressed_exception"
       register_cop :SuppressedExceptionInNumberConversion, "#{__dir__}/lint/suppressed_exception_in_number_conversion"
       register_cop :SymbolConversion, "#{__dir__}/lint/symbol_conversion"