rubocop-on-rbs 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52b6d2d8d5f69d9af653de61ac795ed71d7ce63663c65450dd842e4c1816c69f
-  data.tar.gz: e81e32efe74897317c3eb4183cfb11e6e65b0bcaa04345261787dfc29eb92741
+  metadata.gz: '08ba6bad1ed2be5adfb8b5afeaf6917521e98618a7279354231e637727774177'
+  data.tar.gz: 9e1ac97d25171ec66ad0815bab269e652ce10b159cb372aad2bd9b0baeeb4913
 SHA512:
-  metadata.gz: 6f7a1fdceb0841f976a3cfe4147e9f17e43e13447702314e03747bbd0565f945615f23e952d7ffd08ba7dd00c46f34b2d5bfcd7d8692d94eaf901d528c776cd1
-  data.tar.gz: f0949c448ec168f168b4d4c2b723670bac8e2dade272e8b569533314c366e26b89b805860f455f49f5a3d1f06294a7ad0334baa8c878ab043459b2cbf22c115f
+  metadata.gz: f8a8c23cfaffc12e440c3b0b8ab6e122e6d68352c481b0b548183329c36967b275627131b25b6a7123da202c84c93e2b2442735f3080fac20b148da12f7c4561
+  data.tar.gz: 800caf959a981ead103d76f611a69ec61ce4828d7e620c48bab82a621b21eea1ca8bccf90bb4c6a7fe6080c155bc29cf2bd6c0886e3707a67e8ae3da3d718581

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [2.2.0] - 2026-09-28
+
+* Mark all `RBSInline/*` cops as `Enabled: pending` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/164
+  * They will be enabled by default in v3.0.0. Use `NewCops: enable` to enable them now.
+* Add `RBSInline` department for RBS inline annotations in Ruby files by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/159
+  * `RBSInline/Lint/Syntax`
+  * `RBSInline/Lint/UnusedAnnotation`
+* Replace crc32 cache with `ObjectSpace::WeakKeyMap` and drop `zlib` dependency by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/160
+* Add `RBSInline/Style` department by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/161
+  * `RBSInline/Style/BlockReturnBoolish`
+  * `RBSInline/Style/ClassWithSingleton`
+  * `RBSInline/Style/ClassicType`
+  * `RBSInline/Style/DuplicatedType`
+  * `RBSInline/Style/EmptyArgument`
+  * `RBSInline/Style/InitializeReturnType`
+  * `RBSInline/Style/InstanceWithInstance`
+  * `RBSInline/Style/OptionalNil`
+  * `RBSInline/Style/RedundantParentheses`
+  * `RBSInline/Style/TrueFalse`
+* Drop steep by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/162
+* Add `RBSInline/Lint` cops sharing implementation with `RBS/Lint` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/163
+  * `RBSInline/Lint/AmbiguousKeywordArgumentKey`
+  * `RBSInline/Lint/DuplicateOverload`
+  * `RBSInline/Lint/LiteralIntersection`
+  * `RBSInline/Lint/NewReturnsVoid`
+  * `RBSInline/Lint/RestKeywordHash`
+  * `RBSInline/Lint/UnusedOverloadTypeParams`
+
+## [2.1.0] - 2026-09-27
+
+* Drop support for Ruby v3.2 by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/153
+* [RBS/Layout/IndentationWidth] Support `Width` option by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/157
+
 ## [2.0.0] - 2026-03-27
 
 * Support rbs v4 by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/145

data/README.md

@@ -104,6 +104,52 @@ RBS/Style:
 $ bundle exec rubocop --only RBS/Style
 ```
 
+### RBSInline
+
+Cops for RBS inline annotations (`#: String`, `# @rbs x: Integer`) written in Ruby files.
+They are separated from `RBS/*` cops and run only on Ruby files that contain annotations.
+
+All `RBSInline/*` cops are `pending` in v2.x and will be enabled by default in v3.0.0.
+To enable them now, set `NewCops: enable` in your `.rubocop.yml`:
+
+```yaml
+AllCops:
+  NewCops: enable
+```
+
+Or enable only the `RBSInline` department (requires RuboCop 1.89+):
+
+```yaml
+RBSInline:
+  NewCops: enable
+```
+
+### RBSInline/Lint
+
+Same as `RBS/Lint`, but for inline annotations.
+
+```yaml
+RBSInline/Lint:
+  Enabled: true
+```
+
+```console
+$ bundle exec rubocop --only RBSInline/Lint
+```
+
+### RBSInline/Style
+
+Same as `RBS/Style`, but for inline annotations.
+
+```yaml
+RBSInline/Style:
+  Enabled: true
+```
+
+```console
+$ bundle exec rubocop --only RBSInline/Style
+```
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/config/default.yml

@@ -77,6 +77,8 @@ RBS/Layout/ExtraSpacing:
 RBS/Layout/IndentationWidth:
   Description: 'Use 2 spaces for indentation'
   Enabled: true
+  # Number of spaces for each indentation level.
+  Width: 2
 
 RBS/Layout/OverloadIndentation:
   Description: 'Indent overload method'
@@ -220,3 +222,112 @@ RBS/Style/RedundantParentheses:
 RBS/Style/TrueFalse:
   Description: 'Use bool instead of true | false'
   Enabled: true
+
+# RBSInline
+
+RBSInline:
+  Enabled: true
+
+## RBSInline/Lint
+
+RBSInline/Lint:
+  Enabled: true
+
+RBSInline/Lint/AmbiguousKeywordArgumentKey:
+  Description: 'Check ambiguous keyword argument key'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/DuplicateOverload:
+  Description: 'Checks that there are no repeated overload bodies'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/LiteralIntersection:
+  Description: 'Check literal intersection'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/NewReturnsVoid:
+  Description: 'sigleton `new` method should not returns `void` type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/RestKeywordHash:
+  Description: 'Check rest keyword with `Hash` type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/Syntax:
+  Severity: error
+  Description: 'Check RBS inline annotation syntax'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+  AllowedPatterns:
+    # Embedded RBS by rbs-inline gem. Not supported by RBS::InlineParser.
+    - '\A# @rbs!'
+
+RBSInline/Lint/UnusedAnnotation:
+  Description: 'Check unused RBS inline annotation'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/UnusedOverloadTypeParams:
+  Description: 'Check redundant overload type params'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+## RBSInline/Style
+
+RBSInline/Style:
+  Enabled: true
+
+RBSInline/Style/BlockReturnBoolish:
+  Description: 'Use `bool` for block return type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/ClassWithSingleton:
+  Description: 'Check `class` with singleton context'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/ClassicType:
+  Description: 'Use simple type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/DuplicatedType:
+  Description: 'Check duplicated type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/EmptyArgument:
+  Description: 'Use `()` for empty argument'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/InitializeReturnType:
+  Description: 'Use `void` for initialize method'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/InstanceWithInstance:
+  Description: 'Check `instance` with instance context'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/OptionalNil:
+  Description: 'Use nil instead of nil?'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/RedundantParentheses:
+  Description: 'Remove redundant parentheses'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/TrueFalse:
+  Description: 'Use bool instead of true | false'
+  Enabled: pending
+  VersionAdded: '2.2.0'

data/lib/rubocop/cop/rbs/layout/annotation_indentation.rb

@@ -35,7 +35,8 @@ module RuboCop
                   when ::RBS::AST::Members::MethodDefinition
                     member.overloads.each do |overload|
                       overload.annotations.each do |annotation|
-                        ignore_poses << annotation.location.start_pos
+                        location = annotation.location or next
+                        ignore_poses << location.start_pos
                       end
                     end
                   end

data/lib/rubocop/cop/rbs/layout/comment_indentation.rb

@@ -46,7 +46,7 @@ module RuboCop
 
           def line_after_comment(comment)
             lines = processed_source.lines
-            lines[comment.location.start_line..].find { |line| !line.blank? }
+            lines[comment.location.start_line..]&.find { |line| !line.blank? }
           end
 
           def correct_indentation(next_line)

data/lib/rubocop/cop/rbs/layout/empty_lines_around_access_modifier.rb

@@ -29,8 +29,9 @@ module RuboCop
           MSG = 'Keep a blank line before and after `<%<kind>s>`.'
 
           def on_rbs_class(decl)
-            @class_or_module_def_first_line = decl.location.start_line
-            @class_or_module_def_last_line = decl.location.end_line
+            location = decl.location or return
+            @class_or_module_def_first_line = location.start_line
+            @class_or_module_def_last_line = location.end_line
           end
           alias on_rbs_module on_rbs_class
 

data/lib/rubocop/cop/rbs/layout/empty_lines_around_body.rb

@@ -4,11 +4,14 @@ module RuboCop
   module Cop
     module RBS
       module Layout
+        # @rbs module-self: RuboCop::RBS::CopBase
         module EmptyLinesAroundBody
           MSG_EXTRA = 'Extra empty line detected at %<kind>s body %<location>s.'
 
           private
 
+          # Main endpoint
+          #: (untyped decl) -> void
           def check(decl)
             first_line = decl.location.start_line
             last_line = decl.location.end_line
@@ -18,14 +21,19 @@ module RuboCop
             check_ending(last_line)
           end
 
+          # Check line after `class/module/interface`
+          #: (Integer first_line) -> void
           def check_beginning(first_line)
             check_source(first_line, 'beginning')
           end
 
+          # Check line before `end`
+          #: (Integer last_line) -> void
           def check_ending(last_line)
             check_source(last_line - 2, 'end')
           end
 
+          #: (Integer line_no, untyped desc) -> void
           def check_source(line_no, desc)
             return unless line_no.positive?
             return unless processed_source.lines[line_no]

data/lib/rubocop/cop/rbs/layout/end_alignment.rb

@@ -42,7 +42,8 @@ module RuboCop
             end_loc = decl.location[:end]
             actual = end_loc.start_column
             if actual != expect
-              line_start_pos = processed_source.raw_source.rindex(/\R/, end_loc.start_pos) + 1
+              newline_pos = processed_source.raw_source.rindex(/\R/, end_loc.start_pos) or return
+              line_start_pos = newline_pos + 1
               range = range_between(end_loc.start_pos, end_loc.end_pos)
               source = decl.location.source.each_line.first.strip
               message = "`end` at #{end_loc.start_line}, #{end_loc.start_column} is not aligned with " \

data/lib/rubocop/cop/rbs/layout/extra_spacing.rb

@@ -38,6 +38,7 @@ module RuboCop
             end
           end
 
+          #: () -> ::Set[Integer]
           def aligned_locations
             comments = processed_rbs_source.tokens.select(&:comment?)
             Set.new.tap do |aligned|

data/lib/rubocop/cop/rbs/layout/indentation_width.rb

@@ -6,7 +6,7 @@ module RuboCop
       module Layout
         # Checks if the indentation width.
         #
-        # @example
+        # @example Width: 2 (default)
         #   # bad
         #   class Foo
         #   def foo: () -> void
@@ -17,6 +17,17 @@ module RuboCop
         #     def foo: () -> void
         #   end
         #
+        # @example Width: 4
+        #   # bad
+        #   class Foo
+        #     def foo: () -> void
+        #   end
+        #
+        #   # good
+        #   class Foo
+        #       def foo: () -> void
+        #   end
+        #
         class IndentationWidth < RuboCop::RBS::CopBase
           extend AutoCorrector
 
@@ -33,7 +44,7 @@ module RuboCop
             if decl.respond_to?(:members)
               check(decl, expect: expect)
               decl.members.each do |member|
-                check_indentation(member, expect: expect + 2)
+                check_indentation(member, expect: expect + configured_indentation_width)
               end
             else
               check(decl, expect: expect)
@@ -52,6 +63,10 @@ module RuboCop
             end
           end
 
+          def configured_indentation_width
+            cop_config['Width'] || 2
+          end
+
           def line_start_pos(decl)
             rindex = processed_source.raw_source.rindex(/\R/, decl.location.start_pos)
             if rindex

data/lib/rubocop/cop/rbs/layout/overload_indentation.rb

@@ -26,11 +26,13 @@ module RuboCop
           extend AutoCorrector
 
           def on_rbs_def(decl)
-            base_pos = decl.location.start_pos
-            base_col = decl.location.start_column
-            overload_starts = decl.overloads.map { |overload| overload.method_type.location.start_pos }
-            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
-            first_colon_column = base_col + tokens.find { |t| t.type == :pCOLON }&.location&.start_column
+            location = decl.location or return
+            base_pos = location.start_pos
+            base_col = location.start_column
+            overload_starts = decl.overloads.filter_map { |overload| overload.method_type.location&.start_pos }
+            tokens = ::RBS::Parser.lex(location.source).value.reject { |t| t.type == :tTRIVIA }
+            colon_column = tokens.find { |t| t.type == :pCOLON }&.location&.start_column or return
+            first_colon_column = base_col + colon_column
             ([nil] + tokens).each_cons(3) do |before, bar, after|
               next unless before
               next unless bar

data/lib/rubocop/cop/rbs/layout/space_after_comma.rb

@@ -20,6 +20,7 @@ module RuboCop
 
           def on_rbs_new_investigation
             processed_rbs_source.tokens.each_cons(2) do |comma, after|
+              next unless comma && after
               next unless comma.type == :pCOMMA
               next unless comma.location
               next unless comma.location.end_line == after.location.start_line

data/lib/rubocop/cop/rbs/layout/space_around_arrow.rb

@@ -27,13 +27,15 @@ module RuboCop
 
           # @sig decl: ::RBS::AST::Members::MethodDefinition
           def on_rbs_def(decl)
-            base = decl.location.start_pos
-            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
+            location = decl.location or return
+            base = location.start_pos
+            tokens = ::RBS::Parser.lex(location.source).value.reject { |t| t.type == :tTRIVIA }
             ([nil] + tokens).each_cons(3) do |before, token, after|
               next unless token&.type == :pARROW
 
               loc = token&.location
               next unless loc
+              next unless after
 
               if before && (before.location.end_pos + 1 != loc.start_pos)
                 next unless before.location.end_line == loc.start_line

data/lib/rubocop/cop/rbs/layout/space_around_braces.rb

@@ -18,9 +18,12 @@ module RuboCop
 
           # @sig decl: ::RBS::AST::Members::MethodDefinition
           def on_rbs_def(decl)
+            location = decl.location or return
             paren_level = 0
-            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
+            tokens = ::RBS::Parser.lex(location.source).value.reject { |t| t.type == :tTRIVIA }
             ([nil] + tokens).each_cons(3) do |before, token, after|
+              next unless token && after
+
               case token.type
               when :pLPAREN # '('
                 paren_level += 1
@@ -31,12 +34,12 @@ module RuboCop
                 next unless (after.type == :pLPAREN || after.type == :pARROW)
                 next unless paren_level == 0
 
-                check_around_space(decl.location, before, token, after)
+                check_around_space(location, before, token, after)
               when :pRBRACE # '}'
                 next unless after.type == :pARROW
                 next unless paren_level == 0
 
-                check_around_space(decl.location, before, token, after)
+                check_around_space(location, before, token, after)
               end
             end
           end

data/lib/rubocop/cop/rbs/layout/space_before_colon.rb

@@ -18,7 +18,7 @@ module RuboCop
           # @sig decl: ::RBS::AST::Members::MethodDefinition
           def on_rbs_def(decl)
             source = processed_source.raw_source
-            loc = decl.location
+            loc = decl.location or return
             colon_start_pos = source.index(':', loc.start_pos)
             return unless colon_start_pos
 

data/lib/rubocop/cop/rbs/lint/ambiguous_keyword_argument_key.rb

@@ -11,50 +11,10 @@ module RuboCop
         #   def foo: (option?: bool, option!: bool, Option: bool) -> void
         #
         class AmbiguousKeywordArgumentKey < RuboCop::RBS::CopBase
+          include RuboCop::Cop::RBS::Mixin::AmbiguousKeywordArgumentKey
           extend AutoCorrector
 
-          # @rbs decl: ::RBS::AST::Members::MethodDefinition
-          def on_rbs_def(decl)
-            decl.overloads.each do |overload|
-              func = overload.method_type.type
-              next unless func.kind_of?(::RBS::Types::Function)
-              next unless !func.required_keywords.empty? || !func.optional_keywords.empty?
-
-              base_pos = overload.method_type.location.start_pos
-              lex_result = ::RBS::Parser.lex(overload.method_type.location.source)
-              buf = []
-              lex_result.value.each do |token|
-                case token.type
-                when :pLPAREN, :pRPAREN, :tTRIVIA
-                  # skip
-                when :pCOLON
-                  next if buf.empty?
-
-                  case buf.last.type
-                  when :pQUESTION
-                    buf.shift if buf.first.type == :pQUESTION
-                    actual = buf.map { |t| t.location.source }.join
-                    did_you_mean = buf.reject { |t| t.location.source == '?' }.map { |t| t.location.source }.join
-                    message = +"`#{actual}` is not local variable name."
-                    if did_you_mean.length > 0
-                      message << " Did you mean `?#{did_you_mean}` for optional keyword argument?"
-                    end
-                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
-                    add_offense(range, message: message)
-                  when :tBANGIDENT, :tUIDENT
-                    buf.shift if buf.first.type == :pQUESTION
-                    actual = buf.map { |t| t.location.source }.join
-                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
-                    add_offense(range, message: "`#{actual}` is not local variable name.")
-                  end
-                when :pCOMMA
-                  buf.clear
-                else
-                  buf << token
-                end
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end

data/lib/rubocop/cop/rbs/lint/ambiguous_operator_precedence.rb

@@ -36,6 +36,8 @@ module RuboCop
 
           def check_type(type)
             on_type([::RBS::Types::Union], type) do |union|
+              next unless union.is_a?(::RBS::Types::Union)
+
               union.types.each do |t|
                 case t
                 when ::RBS::Types::Intersection

data/lib/rubocop/cop/rbs/lint/duplicate_annotation.rb

@@ -23,6 +23,7 @@ module RuboCop
         class DuplicateAnnotation < RuboCop::RBS::CopBase
           MSG = 'Duplicate annotation detected.'
 
+          #: (::RBS::AST::Members::MethodDefinition) -> void
           def on_rbs_def(decl)
             decl.annotations.each_with_index do |annotation, idx|
               next_annotations = decl.annotations[(idx + 1)..] or next
@@ -41,6 +42,7 @@ module RuboCop
             end
           end
 
+          #: (::RBS::AST::Annotation, Array[::RBS::AST::Annotation]) -> void
           def check_annotations(left_annotation, right_annotations)
             right_annotations.each do |right_annotation|
               next unless left_annotation == right_annotation

data/lib/rubocop/cop/rbs/lint/duplicate_overload.rb

@@ -13,31 +13,9 @@ module RuboCop
         #          | () -> top
         #
         class DuplicateOverload < RuboCop::RBS::CopBase
-          MSG = 'Duplicate overload arguments detected.'
+          include RuboCop::Cop::RBS::Mixin::DuplicateOverload
 
-          def on_rbs_def(decl)
-            overloads = decl.overloads
-            overloads.each_with_index do |overload, idx|
-              next if idx == overloads.size - 1
-
-              next_overloads = overloads[(idx + 1)..-1]
-              next_overloads.each do |next_overload|
-                a = method_type_with_untyped_return_type(overload.method_type)
-                b = method_type_with_untyped_return_type(next_overload.method_type)
-                next unless a == b
-
-                range = location_to_range(next_overload.method_type.location)
-                add_offense(range)
-              end
-            end
-          end
-
-          private
-
-          def method_type_with_untyped_return_type(method_type)
-            type = method_type.type.with_return_type(::RBS::Types::Bases::Any.new(location: nil))
-            method_type.update(type:)
-          end
+          alias on_rbs_def check_def
         end
       end
     end

data/lib/rubocop/cop/rbs/lint/literal_intersection.rb

@@ -14,45 +14,14 @@ module RuboCop
         #   1 & _Foo
         #
         class LiteralIntersection < RuboCop::RBS::CopBase
-          MSG = "Don't use literals with `&`."
+          include RuboCop::Cop::RBS::Mixin::LiteralIntersection
 
-          def on_rbs_def(decl)
-            decl.overloads.each do |overload|
-              overload.method_type.each_type do |type|
-                check_type(type)
-              end
-            end
-          end
-
-          def check_type(type)
-            on_type([::RBS::Types::Intersection], type) do |intersection|
-              check_intersection(intersection)
-            end
-          end
-
-          def on_rbs_constant(type)
-            check_type(type.type)
-          end
-          alias on_rbs_global on_rbs_constant
-          alias on_rbs_type_alias on_rbs_constant
-          alias on_rbs_attribute on_rbs_constant
-          alias on_rbs_var on_rbs_constant
-
-          def check_intersection(intersection)
-            intersection.types.each do |type|
-              check_intersection_child(type)
-            end
-          end
-
-          def check_intersection_child(type)
-            case type
-            when ::RBS::Types::Literal
-              range = location_to_range(type.location)
-              add_offense(range)
-            when ::RBS::Types::Intersection
-              check_intersection(type)
-            end
-          end
+          alias on_rbs_def check_def
+          alias on_rbs_constant check_member
+          alias on_rbs_global check_member
+          alias on_rbs_type_alias check_member
+          alias on_rbs_attribute check_member
+          alias on_rbs_var check_member
         end
       end
     end

data/lib/rubocop/cop/rbs/lint/new_returns_void.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rbs_inline: enabled
-
 module RuboCop
   module Cop
     module RBS
@@ -18,24 +16,9 @@ module RuboCop
         #   def self.new: () -> instance
         #
         class NewReturnsVoid < RuboCop::RBS::CopBase
-          MSG = "Don't use `void` in self.new method. Did you mean `instance`?"
-
-          # @rbs decl: RBS::AST::Members::MethodDefinition
-          def on_rbs_def(decl)
-            return unless decl.kind == :singleton
-            return unless decl.name == :new
-
-            decl.overloads.each do |overload|
-              return_type = overload.method_type.type.return_type
-              case return_type
-              when ::RBS::Types::Bases::Void
-                next unless return_type.location
+          include RuboCop::Cop::RBS::Mixin::NewReturnsVoid
 
-                range = location_to_range(return_type.location)
-                add_offense(range)
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end