rubocop-on-rbs 2.0.0.dev → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb12bf04d27c5b1e90a4537e696d0f43e3440653244e71ab14bd189ef876ad1d
-  data.tar.gz: 265c57dc1917d19594e7175696147db9668a48b57c1b463472488e8bae4eade6
+  metadata.gz: 43791277046bd585b3979b68148eb004aa7212cbcdd5301f7d5001915cf20b8a
+  data.tar.gz: b261814ee8ff54554e351e018c688821df1fff4b1bc78c9b6440df53e8db2029
 SHA512:
-  metadata.gz: 808e37b431fcbad539a5fc99910816f15d00ccde4f35c9e3139e76c22b458680ab9a3e5130436d7fe4d83d9967cea0c777f07b542b72cc669b6011a9a20e29a6
-  data.tar.gz: 9951c42a0f33cdca49d1c580ceecbb0d774b3534794e55ed08e69e274a657f8262f218ed759de4ef93c99ffd1aba79da238225f32f96edc2a4e990e5caaa5a46
+  metadata.gz: 0a2e89869da1c6353ba2cf7baec53629244a69538f94e0ae6523cae22165fd4775f78d5bbfd7a0925ce2b992567b256e73a956306d8c0022b599db89f67e092b
+  data.tar.gz: 53fea77b783bd0a3f53a2c59129e2cae7161c78c923cda78ce0ea7875e1a8ed53a2923df8aa438bb1143f3d0bfbfda410f6ab3c3ef0be1ca378664f7679b511c

data/CHANGELOG.md

@@ -1,6 +1,59 @@
 ## [Unreleased]
 
+## [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
+* Drop `RBS/Lint/WillSyntaxError` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/145
+
+## [1.9.1] - 2026-02-10
+
+* [RBS/Layout/OverloadIndentation] Fix false positive by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/141
+* [RBS/Layout/EmptyLinesAroundOverloads] Fix false positive by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/142
+* [RBS/Layout/SpaceBeforeOverload] Support `...` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/143
+
+## [1.9.0] - 2026-01-14
+
+* Add cop `RBS/Layout/AnnotationIndentation` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/124
+* Fix bug when multi annotation by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/125
+* [RBS/Layout/SpaceAroundOperators] Support type params by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/126
+* Support new Cops by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/129
+* [RBS/Layout/CommentIndentation] Fix false positive by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/136
+* Use ruby v4 by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/137
+
+## [1.8.0] - 2025-06-26
+
+* Add task for update dependencies by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/110
+* Should melt down Gemfile.lock by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/111
+* Dynamically generate document URLs by version by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/114
+* Add new cop `RBS/Lint/ImplicitlyReturnsNil` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/115
+* [RBS/Lint/DuplicateOverload] Ignore the difference of return type. by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/116
+* Add `RBS/Lint/DuplicateAnnotation` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/117
+* Fix message by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/118
+
+## [1.7.0] - 2025-05-18
+
+* Add `RBS/Lint/RestKeywordHash` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/102
+* Support documentation URL for department by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/103
+* Refine documentation by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/104
+* Add RBS/Layout/EmptyLineBetweenDeclarations by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/105
+* [RBS/Layout/EmptyLineBetweenDeclarations] Short fix by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/106
+
+## [1.6.0] - 2025-04-25
+
+* [RBS::Style::TrueFalse] More support decls by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/97
+* [RBS/Style/OptionalNil] More support decls by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/98
+* [RBS/Style/DuplicatedType] More support decls by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/100
+
+## [1.5.0] - 2025-03-23
+
 * Pluginfy RuboCop on RBS by @ydah in https://github.com/ksss/rubocop-on-rbs/pull/88
+* Drop support for ruby v3.1 by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/90
+* Fix RuboCop RakeTask plugin assignment in README by @ydah in https://github.com/ksss/rubocop-on-rbs/pull/92
 
 ## [1.4.2] - 2025-02-23
 

data/README.md

@@ -24,11 +24,8 @@ def foo: (   void) -> untyped
 sig/foo.rbs:2:11: C: [Correctable] RBS/Layout/ExtraSpacing: Unnecessary spacing detected.
 def foo: (   void) -> untyped
           ^^
-sig/foo.rbs:2:14: W: RBS/Lint/WillSyntaxError: void type is only allowed in return type or generics parameter
-def foo: (   void) -> untyped
-             ^^^^
 
-1 file inspected, 3 offenses detected, 2 offenses autocorrectable
+1 file inspected, 2 offenses detected, 2 offenses autocorrectable
 ```
 
 ## Support VSCode

data/config/default.yml

@@ -27,6 +27,10 @@ RBS:
 RBS/Layout:
   Enabled: true
 
+RBS/Layout/AnnotationIndentation:
+  Description: 'Use 2 spaces for annotation indentation'
+  Enabled: true
+
 RBS/Layout/CommentIndentation:
   Description: 'Use 2 spaces for comment indentation'
   Enabled: true
@@ -73,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'
@@ -172,10 +178,6 @@ RBS/Lint/UnusedTypeAliasTypeParams:
   Description: 'Check redundant type alias type params'
   Enabled: true
 
-RBS/Lint/WillSyntaxError:
-  Description: 'Check RBS will syntax error'
-  Enabled: true
-
 ## RBS/Style
 
 RBS/Style:

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # Checks the indentation of annotations in RBS.
+        #
+        # @example
+        #   # bad
+        #   # comment
+        #     %a{pure}
+        #   def foo: () -> void
+        #
+        #   # good
+        #   # comment
+        #   %a{pure}
+        #   def foo: () -> void
+        #
+        class AnnotationIndentation < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = "Incorrect indentation detected (column %<expect>s instead of %<actual>s)."
+
+          def on_rbs_new_investigation
+            indent_start_lines = Set.new
+            indent_end_lines = Set.new
+            ignore_poses = Set.new
+            processed_rbs_source.decls.each do |decl|
+              walk_decl(decl) do |d|
+                indent_start_lines << d.location.start_line
+                indent_end_lines << d.location.end_line
+                d.members.each do |member|
+                  case member
+                  when ::RBS::AST::Members::MethodDefinition
+                    member.overloads.each do |overload|
+                      overload.annotations.each do |annotation|
+                        location = annotation.location or next
+                        ignore_poses << location.start_pos
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            expected_width = 0
+            last_annotation_line = -1
+            processed_rbs_source.tokens.each do |token|
+              case token.type
+              when :kMODULE, :kCLASS, :kINTERFACE
+                next unless indent_start_lines.include?(token.location.start_line)
+
+                expected_width += 2
+              when :kEND
+                next unless indent_end_lines.include?(token.location.start_line)
+
+                expected_width -= 2
+              when :tANNOTATION
+                next if ignore_poses.include?(token.location.start_pos)
+
+                if token.location.start_column == expected_width
+                  last_annotation_line = token.location.start_line
+                  next
+                end
+                next if last_annotation_line == token.location.start_line
+
+                token_range = location_to_range(token.location)
+                message = format(MSG, expect: expected_width, actual: token.location.start_column)
+                last_annotation_line = token.location.start_line
+                add_offense(token_range, message: message) do |corrector|
+                  line_start_pos = processed_source.buffer.line_range(token.location.start_line).begin_pos
+                  indent = range_between(line_start_pos, token.location.start_pos)
+                  corrector.replace(indent, ' ' * expected_width)
+                end
+              end
+            end
+          end
+
+          def walk_decl(decl, &block)
+            if decl.respond_to?(:members)
+              yield decl
+              decl.members.each { |member| walk_decl(member, &block) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,45 +21,47 @@ module RuboCop
           MSG = "Incorrect indentation detected (column %<expect>s instead of %<actual>s)."
 
           def on_rbs_new_investigation
-            indent_start_lines = Set.new
-            indent_end_lines = Set.new
-            processed_rbs_source.decls.each do |decl|
-              walk_decl(decl) do |d|
-                indent_start_lines << d.location.start_line
-                indent_end_lines << d.location.end_line
-              end
+            comments = processed_rbs_source.tokens.select { |token| token.type == :tLINECOMMENT }
+            comments.each_with_index do |token, comment_index|
+              check(token, comment_index)
             end
+          end
 
-            expected_width = 0
-            processed_rbs_source.tokens.each do |token|
-              case token.type
-              when :kMODULE, :kCLASS, :kINTERFACE
-                next unless indent_start_lines.include?(token.location.start_line)
+          def check(comment_token, _comment_index)
+            next_line = line_after_comment(comment_token)
+            correct_comment_indentation = correct_indentation(next_line)
+            column = comment_token.location.start_column
 
-                expected_width += 2
-              when :kEND
-                next unless indent_end_lines.include?(token.location.start_line)
+            column_delta = correct_comment_indentation - column
+            return if column_delta.zero?
 
-                expected_width -= 2
-              when :tLINECOMMENT
-                if token.location.start_column != expected_width
-                  token_range = location_to_range(token.location)
-                  message = format(MSG, expect: expected_width, actual: token.location.start_column)
-                  add_offense(token_range, message: message) do |corrector|
-                    line_start_pos = processed_source.buffer.line_range(token.location.start_line).begin_pos
-                    indent = range_between(line_start_pos, token.location.start_pos)
-                    corrector.replace(indent, ' ' * expected_width)
-                  end
-                end
-              end
+            token_range = location_to_range(comment_token.location)
+            message = format(MSG, expect: correct_comment_indentation, actual: column)
+            add_offense(token_range, message: message) do |corrector|
+              line_start_pos = processed_source.buffer.line_range(comment_token.location.start_line).begin_pos
+              indent = range_between(line_start_pos, comment_token.location.start_pos)
+              corrector.replace(indent, ' ' * correct_comment_indentation)
             end
           end
 
-          def walk_decl(decl, &block)
-            if decl.respond_to?(:members)
-              yield decl
-              decl.members.each { |member| walk_decl(member, &block) }
-            end
+          def line_after_comment(comment)
+            lines = processed_source.lines
+            lines[comment.location.start_line..]&.find { |line| !line.blank? }
+          end
+
+          def correct_indentation(next_line)
+            return 0 unless next_line
+
+            indentation_of_next_line = next_line =~ /\S/
+            indentation_of_next_line + if less_indented?(next_line)
+                                         2
+                                       else
+                                         0
+                                       end
+          end
+
+          def less_indented?(line)
+            /\A\s*end\b/.match?(line)
           end
         end
       end

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
 
@@ -68,7 +69,7 @@ module RuboCop
           end
 
           def previous_line_ignoring_comments(processed_source, send_line)
-            processed_source[0..send_line - 2].reverse.find { |line| !comment_line?(line) }
+            processed_source[0..(send_line - 2)].reverse.find { |line| !comment_line?(line) }
           end
 
           def previous_line_empty?(send_line)

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

@@ -21,19 +21,35 @@ module RuboCop
 
           MSG = 'Empty line detected around overloads.'
 
+          # @rbs decl: ::RBS::AST::Members::MethodDefinition
+          # @rbs return: void
           def on_rbs_def(decl)
-            return unless 1 < decl.overloads.length
-
             decl.overloads.each_cons(2) do |overload, next_overload|
-              check_empty_lines(overload, next_overload)
+              end_line = overload&.method_type&.location&.end_line || 0
+              next_start_line = next_overload&.method_type&.location&.start_line || 0
+              check_empty_lines(end_line, next_start_line)
+            end
+
+            if decl.overloading? && decl.overloads.length.positive?
+              # : () -> void
+              #
+              #   | ...
+              end_location = decl.overloads.last.method_type.location or return
+              slice = processed_source.raw_source[end_location.end_pos..] or return
+              bar_index = slice.index('|') or return
+              bar_line = slice[0..bar_index]&.count("\n") or return
+              check_empty_lines(end_location.end_line, end_location.end_line + bar_line)
             end
           end
 
-          def check_empty_lines(overload, next_overload)
-            return if overload.method_type.location.end_line + 1 == next_overload.method_type.location.start_line
+          # @rbs end_line: Integer
+          # @rbs next_start_line: Integer
+          # @rbs return: void
+          def check_empty_lines(end_line, next_start_line)
+            return if end_line + 1 == next_start_line
 
             total = 0
-            range = overload.method_type.location.end_line...(next_overload.method_type.location.start_line - 1)
+            range = end_line...(next_start_line - 1)
             processed_source.raw_source.each_line.each_with_index do |line, lineno|
               if range.cover?(lineno) && line == "\n"
                 empty_line = range_between(total, total + 1)

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
@@ -39,8 +41,11 @@ module RuboCop
 
               loc = bar&.location
               next unless loc
-              next unless overload_starts.include?(base_pos + after.location.start_pos)
 
+              # pDOT3 is not included in decl.overloads
+              next unless overload_starts.include?(base_pos + after.location.start_pos) || after.type == :pDOT3
+
+              # () -> void | (Integer) -> void
               if before.location.end_line == bar.location.start_line
                 range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
                 add_offense(range, message: "Insert newline before `|`") do |corrector|
@@ -49,12 +54,17 @@ module RuboCop
                 end
               end
 
+              # () -> void
+              # |
+              # (Integer) -> void
               if bar.location.end_line != after.location.start_line
                 range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
                 add_offense(range, message: "Remove newline after `|`") do |corrector|
                   space = range_between(base_pos + bar.location.end_pos, base_pos + after.location.start_pos)
                   corrector.replace(space, ' ')
                 end
+              # : () -> void
+              #   | (Integer) -> void
               elsif bar.location.start_column != first_colon_column
                 range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
                 add_offense(range, message: 'Indent the `|` to the first `:`') do |corrector|

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_around_operators.rb

@@ -14,8 +14,15 @@ module RuboCop
         class SpaceAroundOperators < RuboCop::RBS::CopBase
           extend AutoCorrector
 
+          def on_rbs_class(decl)
+            check_type_params(decl)
+          end
+          alias on_rbs_module on_rbs_class
+          alias on_rbs_interface on_rbs_class
+
           def on_rbs_def(decl)
             decl.overloads.each do |overload|
+              check_type_params(overload.method_type)
               overload.method_type.each_type do |type|
                 check_type(type)
               end
@@ -26,10 +33,14 @@ module RuboCop
             check_type(decl.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 on_rbs_type_alias(decl)
+            check_type_params(decl)
+            check_type(decl.type)
+          end
+
           def check_type(type)
             case type
             when ::RBS::Types::Union
@@ -42,6 +53,13 @@ module RuboCop
             end
           end
 
+          def check_type_params(decl)
+            decl.type_params.each do |type_param|
+              check_type(type_param.default_type) if type_param.default_type
+              check_type(type_param.upper_bound_type) if type_param.upper_bound_type
+            end
+          end
+
           def check_operator(type, operator)
             type.types.each_cons(2) do |before, after|
               next unless before.location.end_line == after.location.start_line

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