rubocop-on-rbs 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b70070f22849df33c71ad69c0f2a08c1a6a2d0523c19f779868dda630787de43
-  data.tar.gz: 43789ae285bc5e4f155ba5641fed3471cf27715e58007c02e26661d853304084
+  metadata.gz: 889ce959e28673f250187124bfd7955879317482cfdfb976f4bdb975fc918c5b
+  data.tar.gz: 0e0654669928cacd44ca23ad5ece90521ac21660758277fe0af42d3b33377d5b
 SHA512:
-  metadata.gz: 5a3dece661499c49c0f62c9db11c5a3ee5d0e926d4aedbced0c27b09fda4425eaea161663d22cbf3edf7f37a12fd83e56350b6832f4d90eeac17d027dd5c6f3f
-  data.tar.gz: '0662672318876ae0d61e604c3e5e9d7405000fb5632ece629ee7497ba5d45b9e9c0ebd1b11aa687472a07bf4b1fdde988f803975007841c47b21ed313ee3482c'
+  metadata.gz: 1556cdd4bb1116f2f49aca75d39ed229f3f3074e33d338528cb051c97cbcd952f2cb4daec81e0186e54c0794d2c265609e56483c7addcf77ad5d648b2fc68a39
+  data.tar.gz: c77872b3822c006c59d89a637f59366e63a58beb2a0ac7b8b351c1b4428ba353d7e1c8f2480faa5209258649eb25574008ffcb9ce2f25b815a7540b09da60c35

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [0.4.0] - 2024-06-14
+
+* Split RuboCop task by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/6
+* Ignore when return untyped by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/7
+* Split task for steep by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/8
+* Add Style/EmptyArgument by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/9
+* Allow return variable only to use by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/10
+* Remove Style/MergeUntyped by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/11
+* Remove Lint/TypeParamsArity by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/12
+* Regenerate docs by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/13
+* Add RBS/Layout/SpaceAroundOperators by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/14
+* Add RBS/Style/RedundantParentheses by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/15
+* Add RBS/Lint/LiteralIntersection by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/16
+
+## [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,9 +85,9 @@ RBS/Lint/DuplicateOverload:
   Description: 'Checks that there are no repeated overload bodies'
   Enabled: true
 
-RBS/Lint/RedundantOverloadTypeParams:
+RBS/Lint/LiteralIntersection:
   Severity: warning
-  Description: 'Check redundant overload type params'
+  Description: 'Check literal intersection'
   Enabled: true
 
 RBS/Lint/Syntax:
@@ -91,52 +95,10 @@ RBS/Lint/Syntax:
   Description: 'Check RBS syntax'
   Enabled: true
 
-RBS/Lint/TypeParamsArity:
+RBS/Lint/UselessOverloadTypeParams:
   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
+  Description: 'Check redundant overload type params'
+  Enabled: true
 
 RBS/Lint/WillSyntaxError:
   Severity: warning
@@ -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,33 +10,18 @@ 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|
               next if overload.method_type.type_params.empty?
 
-              type_params = overload.method_type.type_params
+              type_params = overload.method_type.type_params.dup
 
-              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,170 @@
+# 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
+          class MethodTypeChecker
+            include RuboCop::RBS::OnTypeHelper
+
+            def initialize(base_type: nil, &block)
+              @base_type = base_type
+              @base = base_type.location.start_pos
+              @tokens = tokenize(base_type.location.source)
+              @block = block
+            end
+
+            def check
+              check_method_argument
+              if @base_type.block
+                check_block_argument
+              end
+              @base_type.each_type do |type|
+                check_type(type)
+              end
+            end
+
+            # [T] () -> void
+            def check_method_argument
+              if @base_type.type_params.empty?
+                will_lparen_token = @tokens[0]
+              else
+                rbracket_index = @tokens.index do |token|
+                  token.location.start_pos + @base >= @base_type.type_params.last.location.end_pos
+                end or raise
+                raise unless @tokens[rbracket_index].type == :pRBRACKET
+
+                will_lparen_token = @tokens[rbracket_index + 1]
+              end
+
+              if will_lparen_token.type != :pLPAREN
+                @block.call(
+                  @base + will_lparen_token.location.start_pos,
+                  @base + will_lparen_token.location.start_pos + 1
+                )
+              end
+            end
+
+            # { () [self: instance] -> void } -> void
+            def check_block_argument
+              return unless @base_type.block
+              return unless @base_type.block.type.each_param.first.nil?
+
+              if @base_type.block.self_type
+                self_type_index = bsearch_token_index(@base_type.block.self_type.location.start_pos)
+                # ) [self:
+                # ^ ^^   ^ => pRPAREN, pLBRACKET, kSELF, pCOLON
+                rparen = @tokens[self_type_index - 4]
+                after_rparen = @tokens[self_type_index - 3]
+              else
+                block_arrow_index = @tokens.find_index { |t| t.type == :pARROW } or raise
+                rparen = @tokens[block_arrow_index - 1]
+                after_rparen = @tokens[block_arrow_index]
+              end
+
+              if rparen.type != :pRPAREN
+                @block.call(
+                  @base + after_rparen.location.start_pos,
+                  @base + after_rparen.location.start_pos + 1
+                )
+              end
+            end
+
+            def check_type(type = @base_type)
+              on_type([::RBS::Types::Proc], type) do |proc_type|
+                check_proc(proc_type)
+              end
+            end
+
+            def check_proc(type)
+              proc_start_index = bsearch_token_index(type.location.start_pos)
+              proc_end_index = bsearch_token_index(type.location.end_pos)
+              if @tokens[proc_start_index + 1].type != :pLPAREN
+                @block.call(
+                  @base + @tokens[proc_start_index + 1].location.start_pos,
+                  @base + @tokens[proc_start_index + 1].location.start_pos + 1
+                )
+              end
+
+              if type.block
+                if type.block&.self_type
+                  self_type_index = bsearch_token_index(type.block.self_type.location.start_pos)
+                  # ) [self:
+                  # ^ ^^   ^ => pRPAREN, pLBRACKET, kSELF, pCOLON
+                  rparen = @tokens[self_type_index - 4]
+                  after_rparen = @tokens[self_type_index - 3]
+                else
+                  block_arrow_index = @tokens[proc_start_index...proc_end_index].find_index { |t|
+                    t.type == :pARROW
+                  } or raise
+                  block_arrow_index += proc_start_index
+                  rparen = @tokens[block_arrow_index - 1]
+                  after_rparen = @tokens[block_arrow_index]
+                end
+
+                if rparen.type != :pRPAREN
+                  @block.call(
+                    @base + after_rparen.location.start_pos,
+                    @base + after_rparen.location.start_pos + 1
+                  )
+                end
+              end
+            end
+
+            private
+
+            def bsearch_token_index(pos)
+              @tokens.bsearch_index do |token|
+                token.location.start_pos + @base >= pos
+              end or raise
+            end
+
+            def tokenize(source)
+              ::RBS::Parser.lex(source).value.reject { |t| t.type == :tTRIVIA }
+            end
+          end
+
+          extend AutoCorrector
+
+          MSG = 'Insert `()` when empty argument'
+
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              MethodTypeChecker.new(base_type: overload.method_type) do |s, e|
+                range = range_between(s, e)
+                add_offense(range) do |corrector|
+                  corrector.insert_before(range, '() ')
+                end
+              end.check
+            end
+          end
+
+          def on_rbs_constant(const)
+            MethodTypeChecker.new(base_type: const.type) do |s, e|
+              range = range_between(s, e)
+              add_offense(range) do |corrector|
+                corrector.insert_before(range, '() ')
+              end
+            end.check_type
+          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/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

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require 'zlib'
+
 module RuboCop
   module RBS
     # Base class for cops that operate on RBS signatures.
     class CopBase < RuboCop::Cop::Base
       include RuboCop::Cop::RangeHelp
+      include RuboCop::RBS::OnTypeHelper
 
       attr_reader :processed_rbs_source
 
@@ -19,11 +22,31 @@ module RuboCop
         investigation_rbs()
       end
 
+      @@cache = {}
+      def parse_rbs
+        buffer = rbs_buffer()
+        @processed_rbs_source = RuboCop::RBS::ProcessedRBSSource.new(buffer)
+      end
+
       def investigation_rbs
         return unless processed_source.buffer.name.then { |n| n.end_with?(".rbs") || n == "(string)" }
 
-        buffer = rbs_buffer()
-        @processed_rbs_source = RuboCop::RBS::ProcessedRBSSource.new(buffer)
+        if processed_source.buffer.name == "(string)"
+          parse_rbs
+        else
+          crc32 = Zlib.crc32(processed_source.raw_source)
+          hit_path = @@cache[processed_source.buffer.name]
+          if hit_path
+            if hit_crc32 = hit_path[crc32]
+              @processed_rbs_source = hit_crc32
+            else
+              hit_path.clear # Other key expect clear by GC
+              hit_path[crc32] = parse_rbs
+            end
+          else
+            (@@cache[processed_source.buffer.name] ||= {})[crc32] = parse_rbs
+          end
+        end
 
         if processed_rbs_source.error
           on_rbs_parsing_error()
@@ -86,6 +109,10 @@ 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
     end
   end
 end

data/lib/rubocop/rbs/on_type_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RBS
+    module OnTypeHelper
+      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.5.0'
   end
 end

data/lib/rubocop-on-rbs.rb

@@ -4,6 +4,7 @@ require 'rubocop'
 
 require_relative 'rubocop/rbs'
 require_relative 'rubocop/rbs/version'
+require_relative 'rubocop/rbs/on_type_helper'
 require_relative 'rubocop/rbs/cop_base'
 require_relative 'rubocop/rbs/inject'
 require_relative 'rubocop/rbs/processed_rbs_source'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-on-rbs
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-11 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.41'
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: RuboCop extension for RBS file.
 email:
 - co000ri@gmail.com
@@ -59,25 +73,28 @@ 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
 - lib/rubocop/rbs/cop_base.rb
 - lib/rubocop/rbs/inject.rb
+- lib/rubocop/rbs/on_type_helper.rb
 - lib/rubocop/rbs/processed_rbs_source.rb
 - lib/rubocop/rbs/version.rb
 homepage: https://github.com/ksss/rubocop-on-rbs

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