rubocop-on-rbs 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2d0a08d15b11889f3e9cb30b870ab7f10708d79fc88984271cd0d1d229a6eb2
-  data.tar.gz: c5bbecab5e33bbbddcab3081b1df9c0370948e1c4cbd2fbe9ea1f9bb8e7cf820
+  metadata.gz: adb415dc438caa7d859497f2915d37fe647ba2c0a0c396a1afc79f6aec2a53ee
+  data.tar.gz: 621b0e9338aab521860cf7e73c7b346015f3e9e51b6af06d9159b1844083281a
 SHA512:
-  metadata.gz: 8153af6d71ecd6f087d9511de6a3caa2ded02a2edf6a1e51833a212d1a1fee269bfcf8c398b536ce89fedebf91b86784aba445117779101a64efb83e1082ffd8
-  data.tar.gz: aa38d915d25385ae67af7a84d7b480b28fcd23a6e4110e273e5d42571ff1b7bf5daf0116c7803b14297cbbd4a4f4e706836b2b1d6bc770edf8d81104f76aff46
+  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.
@@ -117,15 +119,13 @@ $ bundle exec rubocop --only RBS/Style
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add rubocop-on-rbs --require false
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ gem install rubocop-on-rbs
 
 ## Usage
 

data/config/default.yml

@@ -11,6 +11,10 @@ Lint:
   Exclude:
     - '**/*.rbs'
 
+Style:
+  Exclude:
+    - '**/*.rbs'
+
 # RBS
 
 RBS:
@@ -55,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
@@ -70,64 +78,30 @@ RBS/Layout/TrailingWhitespace:
 ## RBS/Lint
 
 RBS/Lint:
-  Severity: warning
   Enabled: true
 
-RBS/Lint/Syntax:
-  Description: 'Check RBS syntax'
+RBS/Lint/DuplicateOverload:
+  Severity: warning
+  Description: 'Checks that there are no repeated overload bodies'
   Enabled: true
 
-RBS/Lint/TypeParamsArity:
-  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/LiteralIntersection:
+  Severity: warning
+  Description: 'Check literal intersection'
+  Enabled: true
 
 RBS/Lint/UselessOverloadTypeParams:
-  Description: 'Check useless overload type params'
+  Severity: warning
+  Description: 'Check redundant overload type params'
+  Enabled: true
+
+RBS/Lint/Syntax:
+  Severity: fatal
+  Description: 'Check RBS syntax'
   Enabled: true
 
 RBS/Lint/WillSyntaxError:
+  Severity: warning
   Description: 'Check RBS will syntax error'
   Enabled: true
 
@@ -148,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/duplicate_overload.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # Checks that there are no repeated overload bodies
+        #
+        # @example default
+        #   # bad
+        #   def foo: () -> void
+        #          | () -> void
+        #
+        class DuplicateOverload < RuboCop::RBS::CopBase
+          MSG = 'Duplicate overload body detected.'
+
+          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|
+                next unless overload.method_type == next_overload.method_type
+
+                range = location_to_range(next_overload.method_type.location)
+                add_offense(range)
+              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/useless_overload_type_params.rb

@@ -10,11 +10,8 @@ module RuboCop
         #   # bad
         #   def foo: [T] () -> void
         #
-        #   # bad
-        #   def bar: [T, U] (T) -> void
-        #
         #   # good
-        #   def foo: [T] (Array[T]) -> T
+        #   def foo: [T] (T) -> T
         class UselessOverloadTypeParams < RuboCop::RBS::CopBase
           MSG = 'Useless overload type variable - `%<variable>s`.'
 

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,19 +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/syntax'
-require_relative 'rbs/lint/type_params_arity'
+require_relative 'rbs/lint/duplicate_overload'
+require_relative 'rbs/lint/literal_intersection'
 require_relative 'rbs/lint/useless_overload_type_params'
+require_relative 'rbs/lint/syntax'
 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.2.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.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-06 00:00:00.000000000 Z
+date: 2024-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -59,19 +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/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