rubocop-on-rbs 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b70070f22849df33c71ad69c0f2a08c1a6a2d0523c19f779868dda630787de43
-  data.tar.gz: 43789ae285bc5e4f155ba5641fed3471cf27715e58007c02e26661d853304084
+  metadata.gz: adb415dc438caa7d859497f2915d37fe647ba2c0a0c396a1afc79f6aec2a53ee
+  data.tar.gz: 621b0e9338aab521860cf7e73c7b346015f3e9e51b6af06d9159b1844083281a
 SHA512:
-  metadata.gz: 5a3dece661499c49c0f62c9db11c5a3ee5d0e926d4aedbced0c27b09fda4425eaea161663d22cbf3edf7f37a12fd83e56350b6832f4d90eeac17d027dd5c6f3f
-  data.tar.gz: '0662672318876ae0d61e604c3e5e9d7405000fb5632ece629ee7497ba5d45b9e9c0ebd1b11aa687472a07bf4b1fdde988f803975007841c47b21ed313ee3482c'
+  metadata.gz: 6e3357ceba540c5c6ee25188804ebe95965147e47970bc39c98fd8fe60eb8f52af762c1a3a90ca9e68be9d63e2263622cffc983b029232fd23f89d6f536a12b3
+  data.tar.gz: a9155f9687029947fb9bb4d0c47332a5bc3075e400872ebf1e58312f7d6cd47ffa0d37c4005c644adb08e88494c8c14d84a063e2550590db93c75ac7e95f0136

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.3.0] - 2024-06-11
+
+* Implement RedundantOverloadTypeParams instead of UselessOverloadTypeParams by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/1
+* Introduce RBS/Lint/DuplicateOverload by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/2
+* Fix typo by @ydah in https://github.com/ksss/rubocop-on-rbs/pull/3
+* Remove unnecessary Exclude settings in  .rubocop.yml by @ydah in https://github.com/ksss/rubocop-on-rbs/pull/4
+* Generate docs for cop by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/5
+
 ## [0.1.0] - 2024-05-15
 
 - Initial release

data/README.md

@@ -64,6 +64,10 @@ And restart VSCode.
 
 ## Departments
 
+You can see documentation for all cops.
+
+https://github.com/ksss/rubocop-on-rbs/blob/main/docs/modules/ROOT/pages/cops.adoc
+
 ### RBS
 
 This gem handles many cops.
@@ -74,8 +78,6 @@ RBS:
   Enabled: true
 ```
 
-See `config/default.yml` for all Cop.
-
 ### RBS/Layout
 
 This department is a collection of relatively minor fixes has been gathered.

data/config/default.yml

@@ -59,6 +59,10 @@ RBS/Layout/SpaceAroundBraces:
   Description: 'Use space around `{}`'
   Enabled: true
 
+RBS/Layout/SpaceAroundOperators:
+  Description: 'Use space around `|` or `&`'
+  Enabled: true
+
 RBS/Layout/SpaceBeforeColon:
   Description: 'Use space before `:`'
   Enabled: true
@@ -81,7 +85,12 @@ RBS/Lint/DuplicateOverload:
   Description: 'Checks that there are no repeated overload bodies'
   Enabled: true
 
-RBS/Lint/RedundantOverloadTypeParams:
+RBS/Lint/LiteralIntersection:
+  Severity: warning
+  Description: 'Check literal intersection'
+  Enabled: true
+
+RBS/Lint/UselessOverloadTypeParams:
   Severity: warning
   Description: 'Check redundant overload type params'
   Enabled: true
@@ -91,53 +100,6 @@ RBS/Lint/Syntax:
   Description: 'Check RBS syntax'
   Enabled: true
 
-RBS/Lint/TypeParamsArity:
-  Severity: warning
-  Description: 'Check type params arity'
-  Enabled: true
-  Expects:
-    # Default expects.
-    # You can add expects in .rubocop.yml.
-
-    ## class/module
-    Array: 1
-    Enumerable: 1
-    Enumerator: 2
-    Enumerator::Chain: 1
-    Enumerator::Generator: 1
-    Enumerator::Lazy: 2
-    Enumerator::Product: 1
-    FrozenError: 1
-    Hash: 2
-    KeyError: 2
-    NameError: 1
-    NoMatchingPatternKeyError: 2
-    NoMethodError: 1
-    ObjectSpace::WeakKeyMap: 2
-    Range: 1
-    Set: 1
-    Struct: 1
-
-    ## interface
-    Array::_Pattern: 1
-    Enumerable::_NotFound: 1
-    Gem::_HashLike: 2
-    Kernel::_RationalDiv: 1
-    Marshal::_Proc: 1
-    String::_MatchAgainst: 2
-    _Each: 1
-    _EachEntry: 1
-    _Range: 1
-    _ToA: 1
-    _ToAry: 1
-    _ToH: 2
-    _ToHash: 2
-
-    ## type alias
-    array: 1
-    hash: 2
-    range: 1
-
 RBS/Lint/WillSyntaxError:
   Severity: warning
   Description: 'Check RBS will syntax error'
@@ -160,18 +122,22 @@ RBS/Style/DuplicatedType:
   Description: 'Check duplicated type'
   Enabled: true
 
-RBS/Style/InitializeReturnType:
-  Description: 'Use `void` for initialize method'
+RBS/Style/EmptyArgument:
+  Description: 'Use `()` for empty argument'
   Enabled: true
 
-RBS/Style/MergeUntyped:
-  Description: 'Merge to `untyped`'
+RBS/Style/InitializeReturnType:
+  Description: 'Use `void` for initialize method'
   Enabled: true
 
 RBS/Style/OptionalNil:
   Description: 'Use nil instead of nil?'
   Enabled: true
 
+RBS/Style/RedundantParentheses:
+  Description: 'Remove redundant parentheses'
+  Enabled: true
+
 RBS/Style/TrueFalse:
   Description: 'Use bool instead of true | false'
   Enabled: true

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   Integer|String
+        #
+        #   # good
+        #   Integer | String
+        class SpaceAroundOperators < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                on_type(type)
+              end
+            end
+          end
+
+          def on_type(type)
+            case type
+            when ::RBS::Types::Union
+              check_operator(type, '|')
+            when ::RBS::Types::Intersection
+              check_operator(type, '&')
+            end
+            type.each_type do |t|
+              on_type(t)
+            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
+
+              operator_index = type.location.source.index(
+                operator,
+                before.location.end_pos - type.location.start_pos
+              ) or raise
+              operator_index += type.location.start_pos
+              operator_range = range_between(operator_index, operator_index + 1)
+
+              before_char = processed_source.raw_source[operator_index - 1]
+              if before_char != ' '
+                add_offense(operator_range, message: "Use one space before `#{operator}`.") do |corrector|
+                  corrector.insert_before(operator_range, ' ')
+                end
+              end
+
+              after_char = processed_source.raw_source[operator_index + 1]
+              if after_char != ' '
+                add_offense(operator_range, message: "Use one space after `#{operator}`.") do |corrector|
+                  corrector.insert_after(operator_range, ' ')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # Checks that there are no repeated overload bodies
+        #
+        # @example default
+        #   # bad
+        #   1 & 2
+        #
+        #   # bad
+        #   1 & _Foo
+        #
+        class LiteralIntersection < RuboCop::RBS::CopBase
+          MSG = "Don't use literals with `&`."
+
+          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
+
+          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
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/lint/{redundant_overload_type_params.rb → useless_overload_type_params.rb}

@@ -10,16 +10,10 @@ module RuboCop
         #   # bad
         #   def foo: [T] () -> void
         #
-        #   # bad
-        #   def bar: [T] () -> T
-        #
-        #   # bad
-        #   def baz: [T] () { () -> T } -> void
-        #
         #   # good
-        #   def foo: [T] (Array[T]) -> T
-        class RedundantOverloadTypeParams < RuboCop::RBS::CopBase
-          MSG = 'Redundant overload type variable - `%<variable>s`.'
+        #   def foo: [T] (T) -> T
+        class UselessOverloadTypeParams < RuboCop::RBS::CopBase
+          MSG = 'Useless overload type variable - `%<variable>s`.'
 
           def on_rbs_def(decl)
             decl.overloads.each do |overload|
@@ -27,16 +21,7 @@ module RuboCop
 
               type_params = overload.method_type.type_params
 
-              types = []
-              overload.method_type.type.each_param do |param|
-                types << param.type
-              end
-              overload.method_type.block&.then do |block|
-                block.type.each_type do |t|
-                  types << t
-                end
-              end
-              types.each do |type|
+              overload.method_type.each_type do |type|
                 used_variable_in_type(type) do |var|
                   type_params.delete_if { |type_param| type_param.name == var.name }
                 end

data/lib/rubocop/cop/rbs/style/empty_argument.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: -> void
+        #
+        #   # bad
+        #   def foo: () { -> void } -> void
+        #
+        #   # bad
+        #   def foo: () -> ^ -> void
+        #
+        #   # good
+        #   def foo: () { () -> void } -> ^() -> void
+        class EmptyArgument < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = 'Insert `()` when empty argument'
+
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              if !overload.method_type.location.source.start_with?('(')
+                range = range_between(overload.method_type.location.start_pos, overload.method_type.location.start_pos)
+                add_offense(range) do |corrector|
+                  corrector.insert_before(range, '()')
+                end
+              end
+              if overload.method_type.block
+                tokens = tokenize(overload.method_type.location.source)
+                block_arrow_index = tokens.find_index { |t| t.type == :pARROW } or raise
+                if tokens[block_arrow_index - 1].type != :pRPAREN
+                  range = range_between(
+                    overload.method_type.location.start_pos + tokens[block_arrow_index].location.start_pos,
+                    overload.method_type.location.start_pos + tokens[block_arrow_index].location.start_pos
+                  )
+                  add_offense(range) do |corrector|
+                    corrector.insert_before(range, '()')
+                  end
+                end
+              end
+
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          def on_rbs_constant(const)
+            check_type(const.type)
+          end
+          alias on_rbs_global on_rbs_constant
+          alias on_rbs_type_alias on_rbs_constant
+          alias on_rbs_attribute on_rbs_constant
+
+          def check_type(type)
+            case type
+            when ::RBS::Types::Proc
+              check_proc(type)
+            else
+              type.each_type do |t|
+                check_type(t)
+              end
+            end
+          end
+
+          def check_proc(type)
+            tokens = tokenize(type.location.source)
+            if tokens[1].type != :pLPAREN
+              range = range_between(
+                type.location.start_pos + tokens[0].location.end_pos,
+                type.location.start_pos + tokens[0].location.end_pos
+              )
+              add_offense(range) do |corrector|
+                corrector.insert_after(range, '()')
+              end
+            end
+
+            if type.block
+              block_arrow_index = tokens.find_index { |t| t.type == :pARROW } or raise
+              if tokens[block_arrow_index - 1].type != :pRPAREN
+                range = range_between(
+                  type.location.start_pos + tokens[block_arrow_index].location.start_pos,
+                  type.location.start_pos + tokens[block_arrow_index].location.start_pos
+                )
+                add_offense(range) do |corrector|
+                  corrector.insert_before(range, '()')
+                end
+              end
+            end
+          end
+
+          def tokenize(source)
+            ::RBS::Parser.lex(source).value.reject { |t| t.type == :tTRIVIA }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/initialize_return_type.rb

@@ -6,18 +6,17 @@ module RuboCop
       module Style
         # @example default
         #   # bad
-        #   def initialize: () -> untyped
-        #
-        #   # bad
         #   def initialize: () -> nil
         #
         #   # good
+        #   def initialize: () -> untyped
+        #
+        #   # good
         #   def initialize: () -> void
         class InitializeReturnType < RuboCop::RBS::CopBase
           extend AutoCorrector
           MSG = '`#initialize` method should return `void`'
 
-          # @sig decl: ::RBS::AST::Members::MethodDefinition
           def on_rbs_def(decl)
             return unless decl.name == :initialize
             return unless decl.kind == :instance
@@ -25,6 +24,7 @@ module RuboCop
 
             decl.overloads.each do |overload|
               return_type = overload.method_type.type.return_type
+              next if return_type.is_a?(::RBS::Types::Bases::Any)
               next if return_type.is_a?(::RBS::Types::Bases::Void)
 
               range = location_to_range(return_type.location)

data/lib/rubocop/cop/rbs/style/redundant_parentheses.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: () -> (bool)
+        #
+        #   # bad
+        #   def foo: (((true | false))) -> void
+        #
+        #   # good
+        #   def foo: () -> bool
+        #
+        #   # good
+        #   def foo: ((true | false)) -> bool
+        class RedundantParentheses < RuboCop::RBS::CopBase
+          module BeforeTokenIfLparen
+            def before_token_if_lparen(tokens, base, fun)
+              first_param = fun.each_param.first
+              return unless first_param
+
+              b, _ = token_before_after(tokens, first_param.location.start_pos - base)
+              return unless b&.type == :pLPAREN
+
+              yield b
+            end
+
+            private
+
+            def token_before_after(tokens, pos)
+              token_index = tokens.bsearch_index do |t|
+                t.location.start_pos >= pos
+              end
+              return unless token_index
+
+              [
+                tokens[token_index - 1],
+                tokens[token_index + 1]
+              ]
+            end
+          end
+
+          class ParenChecker
+            include BeforeTokenIfLparen
+            include RangeHelp
+            attr_reader :processed_source
+
+            def initialize(processed_source:, base:, tokens:, type:, skip:, cop:)
+              @processed_source = processed_source
+              @base = base
+              @tokens = tokens
+              @type = type
+              @skip = skip
+              @cop = cop
+            end
+
+            def check
+              @cop.on_type([::RBS::Types::Proc], @type) do |proc_type|
+                before_token_if_lparen(@tokens, @base, proc_type.type) do |b|
+                  @skip << (b.location.start_pos + @base)
+                end
+                if proc_type.block
+                  before_token_if_lparen(@tokens, @base, proc_type.block.type) do |b|
+                    @skip << (b.location.start_pos + @base)
+                  end
+                end
+              end
+
+              excludes = [
+                ::RBS::Types::Union,
+                ::RBS::Types::Intersection,
+                ::RBS::Types::Proc
+              ]
+              @cop.on_not_type(excludes, @type) do |type|
+                check_parentheses(type)
+              end
+            end
+
+            def check_parentheses(type)
+              type_token_start_index = @tokens.bsearch_index do |token|
+                (token.location.start_pos + @base) >= type.location.start_pos
+              end or raise
+              before_token = @tokens[type_token_start_index - 1]
+              return if @skip.include?(before_token.location.start_pos + @base)
+              return if before_token&.type != :pLPAREN
+
+              type_token_end_index = @tokens.bsearch_index do |token|
+                (token.location.start_pos + @base) >= type.location.end_pos
+              end or raise
+              after_token = @tokens[type_token_end_index]
+              return if after_token&.type != :pRPAREN
+
+              range = range_between(before_token.location.start_pos + @base, after_token.location.end_pos + @base)
+              @cop.add_offense(range, message: "Don't use parentheses around simple type.") do |corrector|
+                corrector.remove(range_between(before_token.location.start_pos + @base,
+                                               before_token.location.end_pos + @base))
+                corrector.remove(range_between(after_token.location.start_pos + @base,
+                                               after_token.location.end_pos + @base))
+              end
+            end
+          end
+
+          include BeforeTokenIfLparen
+          extend AutoCorrector
+
+          def on_rbs_def(decl)
+            base = decl.location.start_pos
+            tokens = tokenize(decl.location.source)
+            skip = Set.new
+            decl.overloads.each do |overload|
+              before_token_if_lparen(tokens, base, overload.method_type.type) do |b|
+                skip << (b.location.start_pos + base)
+              end
+              if overload.method_type.block
+                before_token_if_lparen(tokens, base, overload.method_type.block.type) do |b|
+                  skip << (b.location.start_pos + base)
+                end
+              end
+              overload.method_type.each_type do |type|
+                check_type(tokens:, type:, base:, skip:)
+              end
+            end
+          end
+
+          def check_type(tokens:, type:, base:, skip: Set.new)
+            ParenChecker.new(
+              processed_source:,
+              base:,
+              tokens:,
+              type:,
+              skip:,
+              cop: self
+            ).check
+          end
+
+          def on_rbs_constant(const)
+            tokens = tokenize(const.location.source)
+            type = const.type
+            base = const.location.start_pos
+            check_type(tokens:, type:, base:)
+          end
+          alias on_rbs_global on_rbs_constant
+          alias on_rbs_type_alias on_rbs_constant
+          alias on_rbs_attribute on_rbs_constant
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs_cops.rb

@@ -10,20 +10,22 @@ require_relative 'rbs/layout/indentation_width'
 require_relative 'rbs/layout/overload_indentation'
 require_relative 'rbs/layout/space_around_arrow'
 require_relative 'rbs/layout/space_around_braces'
+require_relative 'rbs/layout/space_around_operators'
 require_relative 'rbs/layout/space_before_colon'
 require_relative 'rbs/layout/space_before_overload'
 require_relative 'rbs/layout/trailing_whitespace'
 
 require_relative 'rbs/lint/duplicate_overload'
-require_relative 'rbs/lint/redundant_overload_type_params'
+require_relative 'rbs/lint/literal_intersection'
+require_relative 'rbs/lint/useless_overload_type_params'
 require_relative 'rbs/lint/syntax'
-require_relative 'rbs/lint/type_params_arity'
 require_relative 'rbs/lint/will_syntax_error'
 
 require_relative 'rbs/style/block_return_boolish'
-require_relative 'rbs/style/true_false'
 require_relative 'rbs/style/classic_type'
-require_relative 'rbs/style/optional_nil'
 require_relative 'rbs/style/duplicated_type'
+require_relative 'rbs/style/empty_argument'
 require_relative 'rbs/style/initialize_return_type'
-require_relative 'rbs/style/merge_untyped'
+require_relative 'rbs/style/optional_nil'
+require_relative 'rbs/style/redundant_parentheses'
+require_relative 'rbs/style/true_false'

data/lib/rubocop/rbs/cop_base.rb

@@ -86,6 +86,32 @@ module RuboCop
       def location_to_range(location)
         range_between(location.start_pos, location.end_pos)
       end
+
+      def tokenize(source)
+        ::RBS::Parser.lex(source).value.reject { |t| t.type == :tTRIVIA }
+      end
+
+      def on_type(types, type, &block)
+        case type
+        when *types
+          yield type
+        end
+        type.each_type do |t|
+          on_type(types, t, &block)
+        end
+      end
+
+      def on_not_type(types, type, &block)
+        case type
+        when *types
+          # not
+        else
+          yield type
+        end
+        type.each_type do |t|
+          on_not_type(types, t, &block)
+        end
+      end
     end
   end
 end

data/lib/rubocop/rbs/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RBS
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-on-rbs
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-11 00:00:00.000000000 Z
+date: 2024-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -59,20 +59,22 @@ files:
 - lib/rubocop/cop/rbs/layout/overload_indentation.rb
 - lib/rubocop/cop/rbs/layout/space_around_arrow.rb
 - lib/rubocop/cop/rbs/layout/space_around_braces.rb
+- lib/rubocop/cop/rbs/layout/space_around_operators.rb
 - lib/rubocop/cop/rbs/layout/space_before_colon.rb
 - lib/rubocop/cop/rbs/layout/space_before_overload.rb
 - lib/rubocop/cop/rbs/layout/trailing_whitespace.rb
 - lib/rubocop/cop/rbs/lint/duplicate_overload.rb
-- lib/rubocop/cop/rbs/lint/redundant_overload_type_params.rb
+- lib/rubocop/cop/rbs/lint/literal_intersection.rb
 - lib/rubocop/cop/rbs/lint/syntax.rb
-- lib/rubocop/cop/rbs/lint/type_params_arity.rb
+- lib/rubocop/cop/rbs/lint/useless_overload_type_params.rb
 - lib/rubocop/cop/rbs/lint/will_syntax_error.rb
 - lib/rubocop/cop/rbs/style/block_return_boolish.rb
 - lib/rubocop/cop/rbs/style/classic_type.rb
 - lib/rubocop/cop/rbs/style/duplicated_type.rb
+- lib/rubocop/cop/rbs/style/empty_argument.rb
 - lib/rubocop/cop/rbs/style/initialize_return_type.rb
-- lib/rubocop/cop/rbs/style/merge_untyped.rb
 - lib/rubocop/cop/rbs/style/optional_nil.rb
+- lib/rubocop/cop/rbs/style/redundant_parentheses.rb
 - lib/rubocop/cop/rbs/style/true_false.rb
 - lib/rubocop/cop/rbs_cops.rb
 - lib/rubocop/rbs.rb

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

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RBS
-      module Lint
-        # This cop checks the arity of type parameters arity.
-        # You can add expect settings in your .rubocop.yml.
-        #
-        # @example Expects settings
-        #   RBS/Lint/TypeParamsArity:
-        #     Expects:
-        #       Your::Class: 1
-        #
-        # @example default
-        #   # bad
-        #   type a = Array[Integer, String, Symbol]
-        #
-        #   # bad
-        #   class Foo
-        #     include Enumerable
-        #   end
-        class TypeParamsArity < RuboCop::RBS::CopBase
-          Types = ::RBS::Types
-
-          def on_rbs_module(decl)
-            check_type_params(decl)
-            decl.self_types.each do |self_type|
-              check(
-                name: self_type.name,
-                args: self_type.args,
-                location: self_type.location
-              )
-            end
-            check_each_mixin(decl)
-          end
-
-          def on_rbs_class(decl)
-            check_type_params(decl)
-            if decl.super_class
-              check(
-                name: decl.super_class.name,
-                args: decl.super_class.args,
-                location: decl.super_class.location
-              )
-            end
-            check_each_mixin(decl)
-          end
-
-          def on_rbs_interface(decl)
-            check_type_params(decl)
-            check_each_mixin(decl)
-          end
-
-          def on_rbs_constant(const)
-            check_type(const.type)
-          end
-
-          def on_rbs_global(global)
-            check_type(global.type)
-          end
-
-          def on_rbs_type_alias(decl)
-            check_type_params(decl)
-            check_type(decl.type)
-            decl.type.each_type do |type|
-              check_type(type)
-            end
-          end
-
-          def on_rbs_def(member)
-            member.overloads.each do |overload|
-              overload.method_type.each_type do |type|
-                check_type(type)
-              end
-            end
-          end
-
-          def on_rbs_attribute(attr)
-            check_type(attr.type)
-          end
-
-          def check_each_mixin(decl)
-            decl.each_mixin do |mixin|
-              check(
-                name: mixin.name,
-                args: mixin.args,
-                location: mixin.location
-              )
-            end
-          end
-
-          def check_type_params(decl)
-            decl.type_params.each do |type_param|
-              if type_param.upper_bound
-                check(
-                  name: type_param.upper_bound.name,
-                  args: type_param.upper_bound.args,
-                  location: type_param.upper_bound.location
-                )
-              end
-            end
-          end
-
-          def check_type(type)
-            case type
-            when Types::Record,
-                 Types::Tuple,
-                 Types::Union,
-                 Types::Intersection,
-                 Types::Optional,
-                 Types::Proc
-              type.each_type.each do |t|
-                check_type(t)
-              end
-            when Types::Interface,
-                 Types::Alias,
-                 Types::ClassInstance
-              check(
-                name: type.name,
-                args: type.args,
-                location: type.location,
-              )
-            end
-          end
-
-          def check(name:, args:, location:)
-            return unless name.absolute?
-            return unless location
-
-            expect_size = expects[name.to_s]
-            return unless expect_size
-            return unless expect_size != args.size
-
-            message = if args.size == 0
-                        "Type `#{name}` is generic but used as a non generic type."
-                      else
-                        "Type `#{name}` expects #{expect_size} arguments, but #{args.size} arguments are given."
-                      end
-            add_offense(
-              location_to_range(location),
-              message: message,
-              severity: :error
-            )
-          end
-
-          def expects
-            @expects ||= begin
-              expects = cop_config['Expects']
-              raise "Expects must be a hash" unless expects.is_a?(Hash)
-
-              unless expects.all? { |k, _| k.is_a?(String) }
-                raise "[RBS/Lint/TypeParamsArity] Keys of Expects must be strings"
-              end
-              unless expects.all? { |_, v| v.is_a?(Integer) }
-                raise "[RBS/Lint/TypeParamsArity] Values of Expects must be integers"
-              end
-
-              expects.transform_keys! do |k|
-                k.start_with?('::') ? k : "::#{k}"
-              end
-
-              expects
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rbs/style/merge_untyped.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RBS
-      module Style
-        # @example default
-        #   # bad
-        #   def foo: (untyped?) -> untyped?
-        #
-        #   # bad
-        #   def foo: (Integer | untyped) -> (Integer | untyped)
-        #
-        #   # bad
-        #   def foo: (Integer & untyped) -> (Integer & untyped)
-        #
-        #   # good
-        #   def foo: (untyped) -> untyped
-        class MergeUntyped < RuboCop::RBS::CopBase
-          extend AutoCorrector
-
-          # @sig decl: ::RBS::AST::Members::MethodDefinition
-          def on_rbs_def(decl)
-            decl.overloads.each do |overload|
-              overload.method_type.type.tap do |fun|
-                fun.each_param do |param|
-                  check_type(param.type)
-                end
-                check_type(fun.return_type)
-              end
-            end
-          end
-
-          def check_type(type)
-            find_replacement(type) do |method, t, replaced|
-              case method
-              when :replace
-                range = location_to_range(t.location)
-                add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
-                  corrector.replace(range, replaced.to_s)
-                end
-              when :remove
-                range = t
-                add_offense(range, message: "Remove `?` in Optional") do |corrector|
-                  corrector.remove(range)
-                end
-              end
-            end
-          end
-
-          def find_replacement(type, &block)
-            case type
-            when ::RBS::Types::Optional
-              case type.type
-              when ::RBS::Types::Bases::Any,
-                   ::RBS::Types::Bases::Nil,
-                   ::RBS::Types::Bases::Void,
-                   ::RBS::Types::Bases::Top,
-                   ::RBS::Types::Bases::Bottom
-                # untyped? => untyped
-                block.call([:replace, type, type.type])
-              when ::RBS::Types::Optional
-                # (Integer?)? => Integer?
-                range = Parser::Source::Range.new(processed_source.buffer, type.type.location.end_pos - 1,
-                                                  type.type.location.end_pos)
-                block.call([:remove, range])
-                find_replacement(type.type, &block)
-              when ::RBS::Types::Union, ::RBS::Types::Intersection
-                find_replacement(type.type, &block)
-              end
-            when ::RBS::Types::Union, ::RBS::Types::Intersection
-              # (untyped | Integer) => untyped
-              # (untyped & Integer) => untyped
-              if type.types.any? { |t| t.is_a?(::RBS::Types::Bases::Any) }
-                block.call([:replace, type, 'untyped'])
-              end
-
-              uniqed = type.types.uniq
-              if uniqed.size < type.types.size
-                block.call([:replace, type, type.class.new(types: uniqed, location: nil)])
-              end
-              type.types.each do |t|
-                find_replacement(t, &block)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end