rubocop-on-rbs 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adb415dc438caa7d859497f2915d37fe647ba2c0a0c396a1afc79f6aec2a53ee
-  data.tar.gz: 621b0e9338aab521860cf7e73c7b346015f3e9e51b6af06d9159b1844083281a
+  metadata.gz: 889ce959e28673f250187124bfd7955879317482cfdfb976f4bdb975fc918c5b
+  data.tar.gz: 0e0654669928cacd44ca23ad5ece90521ac21660758277fe0af42d3b33377d5b
 SHA512:
-  metadata.gz: 6e3357ceba540c5c6ee25188804ebe95965147e47970bc39c98fd8fe60eb8f52af762c1a3a90ca9e68be9d63e2263622cffc983b029232fd23f89d6f536a12b3
-  data.tar.gz: a9155f9687029947fb9bb4d0c47332a5bc3075e400872ebf1e58312f7d6cd47ffa0d37c4005c644adb08e88494c8c14d84a063e2550590db93c75ac7e95f0136
+  metadata.gz: 1556cdd4bb1116f2f49aca75d39ed229f3f3074e33d338528cb051c97cbcd952f2cb4daec81e0186e54c0794d2c265609e56483c7addcf77ad5d648b2fc68a39
+  data.tar.gz: c77872b3822c006c59d89a637f59366e63a58beb2a0ac7b8b351c1b4428ba353d7e1c8f2480faa5209258649eb25574008ffcb9ce2f25b815a7540b09da60c35

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [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

data/config/default.yml

@@ -90,16 +90,16 @@ RBS/Lint/LiteralIntersection:
   Description: 'Check literal intersection'
   Enabled: true
 
-RBS/Lint/UselessOverloadTypeParams:
-  Severity: warning
-  Description: 'Check redundant overload type params'
-  Enabled: true
-
 RBS/Lint/Syntax:
   Severity: fatal
   Description: 'Check RBS syntax'
   Enabled: true
 
+RBS/Lint/UselessOverloadTypeParams:
+  Severity: warning
+  Description: 'Check redundant overload type params'
+  Enabled: true
+
 RBS/Lint/WillSyntaxError:
   Severity: warning
   Description: 'Check RBS will syntax error'

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

@@ -19,7 +19,7 @@ module RuboCop
             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
 
               overload.method_type.each_type do |type|
                 used_variable_in_type(type) do |var|

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

@@ -17,85 +17,152 @@ module RuboCop
         #   # good
         #   def foo: () { () -> void } -> ^() -> void
         class EmptyArgument < RuboCop::RBS::CopBase
-          extend AutoCorrector
+          class MethodTypeChecker
+            include RuboCop::RBS::OnTypeHelper
 
-          MSG = 'Insert `()` when empty argument'
+            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 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
+            def check
+              check_method_argument
+              if @base_type.block
+                check_block_argument
               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
+              @base_type.each_type do |type|
+                check_type(type)
               end
+            end
 
-              overload.method_type.each_type do |type|
-                check_type(type)
+            # [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
-          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
+            # { () [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
 
-          def check_type(type)
-            case type
-            when ::RBS::Types::Proc
-              check_proc(type)
-            else
-              type.each_type do |t|
-                check_type(t)
+              if rparen.type != :pRPAREN
+                @block.call(
+                  @base + after_rparen.location.start_pos,
+                  @base + after_rparen.location.start_pos + 1
+                )
               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, '()')
+            def check_type(type = @base_type)
+              on_type([::RBS::Types::Proc], type) do |proc_type|
+                check_proc(proc_type)
               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
+            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
                 )
-                add_offense(range) do |corrector|
-                  corrector.insert_before(range, '()')
+              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
 
-          def tokenize(source)
-            ::RBS::Parser.lex(source).value.reject { |t| t.type == :tTRIVIA }
+          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

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()
@@ -90,28 +113,6 @@ module RuboCop
       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/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.4.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.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-14 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
@@ -80,6 +94,7 @@ files:
 - 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