rubocop-on-rbs 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43791277046bd585b3979b68148eb004aa7212cbcdd5301f7d5001915cf20b8a
-  data.tar.gz: b261814ee8ff54554e351e018c688821df1fff4b1bc78c9b6440df53e8db2029
+  metadata.gz: '08ba6bad1ed2be5adfb8b5afeaf6917521e98618a7279354231e637727774177'
+  data.tar.gz: 9e1ac97d25171ec66ad0815bab269e652ce10b159cb372aad2bd9b0baeeb4913
 SHA512:
-  metadata.gz: 0a2e89869da1c6353ba2cf7baec53629244a69538f94e0ae6523cae22165fd4775f78d5bbfd7a0925ce2b992567b256e73a956306d8c0022b599db89f67e092b
-  data.tar.gz: 53fea77b783bd0a3f53a2c59129e2cae7161c78c923cda78ce0ea7875e1a8ed53a2923df8aa438bb1143f3d0bfbfda410f6ab3c3ef0be1ca378664f7679b511c
+  metadata.gz: f8a8c23cfaffc12e440c3b0b8ab6e122e6d68352c481b0b548183329c36967b275627131b25b6a7123da202c84c93e2b2442735f3080fac20b148da12f7c4561
+  data.tar.gz: 800caf959a981ead103d76f611a69ec61ce4828d7e620c48bab82a621b21eea1ca8bccf90bb4c6a7fe6080c155bc29cf2bd6c0886e3707a67e8ae3da3d718581

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## [Unreleased]
 
+## [2.2.0] - 2026-09-28
+
+* Mark all `RBSInline/*` cops as `Enabled: pending` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/164
+  * They will be enabled by default in v3.0.0. Use `NewCops: enable` to enable them now.
+* Add `RBSInline` department for RBS inline annotations in Ruby files by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/159
+  * `RBSInline/Lint/Syntax`
+  * `RBSInline/Lint/UnusedAnnotation`
+* Replace crc32 cache with `ObjectSpace::WeakKeyMap` and drop `zlib` dependency by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/160
+* Add `RBSInline/Style` department by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/161
+  * `RBSInline/Style/BlockReturnBoolish`
+  * `RBSInline/Style/ClassWithSingleton`
+  * `RBSInline/Style/ClassicType`
+  * `RBSInline/Style/DuplicatedType`
+  * `RBSInline/Style/EmptyArgument`
+  * `RBSInline/Style/InitializeReturnType`
+  * `RBSInline/Style/InstanceWithInstance`
+  * `RBSInline/Style/OptionalNil`
+  * `RBSInline/Style/RedundantParentheses`
+  * `RBSInline/Style/TrueFalse`
+* Drop steep by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/162
+* Add `RBSInline/Lint` cops sharing implementation with `RBS/Lint` by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/163
+  * `RBSInline/Lint/AmbiguousKeywordArgumentKey`
+  * `RBSInline/Lint/DuplicateOverload`
+  * `RBSInline/Lint/LiteralIntersection`
+  * `RBSInline/Lint/NewReturnsVoid`
+  * `RBSInline/Lint/RestKeywordHash`
+  * `RBSInline/Lint/UnusedOverloadTypeParams`
+
 ## [2.1.0] - 2026-09-27
 
 * Drop support for Ruby v3.2 by @ksss in https://github.com/ksss/rubocop-on-rbs/pull/153

data/README.md

@@ -104,6 +104,52 @@ RBS/Style:
 $ bundle exec rubocop --only RBS/Style
 ```
 
+### RBSInline
+
+Cops for RBS inline annotations (`#: String`, `# @rbs x: Integer`) written in Ruby files.
+They are separated from `RBS/*` cops and run only on Ruby files that contain annotations.
+
+All `RBSInline/*` cops are `pending` in v2.x and will be enabled by default in v3.0.0.
+To enable them now, set `NewCops: enable` in your `.rubocop.yml`:
+
+```yaml
+AllCops:
+  NewCops: enable
+```
+
+Or enable only the `RBSInline` department (requires RuboCop 1.89+):
+
+```yaml
+RBSInline:
+  NewCops: enable
+```
+
+### RBSInline/Lint
+
+Same as `RBS/Lint`, but for inline annotations.
+
+```yaml
+RBSInline/Lint:
+  Enabled: true
+```
+
+```console
+$ bundle exec rubocop --only RBSInline/Lint
+```
+
+### RBSInline/Style
+
+Same as `RBS/Style`, but for inline annotations.
+
+```yaml
+RBSInline/Style:
+  Enabled: true
+```
+
+```console
+$ bundle exec rubocop --only RBSInline/Style
+```
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/config/default.yml

@@ -222,3 +222,112 @@ RBS/Style/RedundantParentheses:
 RBS/Style/TrueFalse:
   Description: 'Use bool instead of true | false'
   Enabled: true
+
+# RBSInline
+
+RBSInline:
+  Enabled: true
+
+## RBSInline/Lint
+
+RBSInline/Lint:
+  Enabled: true
+
+RBSInline/Lint/AmbiguousKeywordArgumentKey:
+  Description: 'Check ambiguous keyword argument key'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/DuplicateOverload:
+  Description: 'Checks that there are no repeated overload bodies'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/LiteralIntersection:
+  Description: 'Check literal intersection'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/NewReturnsVoid:
+  Description: 'sigleton `new` method should not returns `void` type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/RestKeywordHash:
+  Description: 'Check rest keyword with `Hash` type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/Syntax:
+  Severity: error
+  Description: 'Check RBS inline annotation syntax'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+  AllowedPatterns:
+    # Embedded RBS by rbs-inline gem. Not supported by RBS::InlineParser.
+    - '\A# @rbs!'
+
+RBSInline/Lint/UnusedAnnotation:
+  Description: 'Check unused RBS inline annotation'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Lint/UnusedOverloadTypeParams:
+  Description: 'Check redundant overload type params'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+## RBSInline/Style
+
+RBSInline/Style:
+  Enabled: true
+
+RBSInline/Style/BlockReturnBoolish:
+  Description: 'Use `bool` for block return type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/ClassWithSingleton:
+  Description: 'Check `class` with singleton context'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/ClassicType:
+  Description: 'Use simple type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/DuplicatedType:
+  Description: 'Check duplicated type'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/EmptyArgument:
+  Description: 'Use `()` for empty argument'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/InitializeReturnType:
+  Description: 'Use `void` for initialize method'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/InstanceWithInstance:
+  Description: 'Check `instance` with instance context'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/OptionalNil:
+  Description: 'Use nil instead of nil?'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/RedundantParentheses:
+  Description: 'Remove redundant parentheses'
+  Enabled: pending
+  VersionAdded: '2.2.0'
+
+RBSInline/Style/TrueFalse:
+  Description: 'Use bool instead of true | false'
+  Enabled: pending
+  VersionAdded: '2.2.0'

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

@@ -11,51 +11,10 @@ module RuboCop
         #   def foo: (option?: bool, option!: bool, Option: bool) -> void
         #
         class AmbiguousKeywordArgumentKey < RuboCop::RBS::CopBase
+          include RuboCop::Cop::RBS::Mixin::AmbiguousKeywordArgumentKey
           extend AutoCorrector
 
-          # @rbs decl: ::RBS::AST::Members::MethodDefinition
-          def on_rbs_def(decl)
-            decl.overloads.each do |overload|
-              func = overload.method_type.type
-              next unless func.kind_of?(::RBS::Types::Function)
-              next unless !func.required_keywords.empty? || !func.optional_keywords.empty?
-
-              location = overload.method_type.location or next
-              base_pos = location.start_pos
-              lex_result = ::RBS::Parser.lex(location.source)
-              buf = []
-              lex_result.value.each do |token|
-                case token.type
-                when :pLPAREN, :pRPAREN, :tTRIVIA
-                  # skip
-                when :pCOLON
-                  next if buf.empty?
-
-                  case buf.last.type
-                  when :pQUESTION
-                    buf.shift if buf.first.type == :pQUESTION
-                    actual = buf.map { |t| t.location.source }.join
-                    did_you_mean = buf.reject { |t| t.location.source == '?' }.map { |t| t.location.source }.join
-                    message = +"`#{actual}` is not local variable name."
-                    if did_you_mean.length > 0
-                      message << " Did you mean `?#{did_you_mean}` for optional keyword argument?"
-                    end
-                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
-                    add_offense(range, message: message)
-                  when :tBANGIDENT, :tUIDENT
-                    buf.shift if buf.first.type == :pQUESTION
-                    actual = buf.map { |t| t.location.source }.join
-                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
-                    add_offense(range, message: "`#{actual}` is not local variable name.")
-                  end
-                when :pCOMMA
-                  buf.clear
-                else
-                  buf << token
-                end
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end

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

@@ -13,32 +13,9 @@ module RuboCop
         #          | () -> top
         #
         class DuplicateOverload < RuboCop::RBS::CopBase
-          MSG = 'Duplicate overload arguments detected.'
+          include RuboCop::Cop::RBS::Mixin::DuplicateOverload
 
-          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] or next
-              next_overloads.each do |next_overload|
-                a = method_type_with_untyped_return_type(overload.method_type)
-                b = method_type_with_untyped_return_type(next_overload.method_type)
-                next unless a == b
-
-                location = next_overload.method_type.location or next
-                range = location_to_range(location)
-                add_offense(range)
-              end
-            end
-          end
-
-          private
-
-          def method_type_with_untyped_return_type(method_type)
-            type = method_type.type.with_return_type(::RBS::Types::Bases::Any.new(location: nil))
-            method_type.update(type:)
-          end
+          alias on_rbs_def check_def
         end
       end
     end

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

@@ -14,45 +14,14 @@ module RuboCop
         #   1 & _Foo
         #
         class LiteralIntersection < RuboCop::RBS::CopBase
-          MSG = "Don't use literals with `&`."
+          include RuboCop::Cop::RBS::Mixin::LiteralIntersection
 
-          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
-          alias on_rbs_var 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
+          alias on_rbs_def check_def
+          alias on_rbs_constant check_member
+          alias on_rbs_global check_member
+          alias on_rbs_type_alias check_member
+          alias on_rbs_attribute check_member
+          alias on_rbs_var check_member
         end
       end
     end

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

@@ -16,24 +16,9 @@ module RuboCop
         #   def self.new: () -> instance
         #
         class NewReturnsVoid < RuboCop::RBS::CopBase
-          MSG = "Don't use `void` in self.new method. Did you mean `instance`?"
+          include RuboCop::Cop::RBS::Mixin::NewReturnsVoid
 
-          # @rbs decl: RBS::AST::Members::MethodDefinition
-          def on_rbs_def(decl)
-            return unless decl.kind == :singleton
-            return unless decl.name == :new
-
-            decl.overloads.each do |overload|
-              return_type = overload.method_type.type.return_type
-              case return_type
-              when ::RBS::Types::Bases::Void
-                next unless return_type.location
-
-                range = location_to_range(return_type.location)
-                add_offense(range)
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end

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

@@ -17,29 +17,9 @@ module RuboCop
         #   # e.g.) foo(a: "x", b: "y", c: "z")
         #
         class RestKeywordHash < RuboCop::RBS::CopBase
-          def on_rbs_def(decl)
-            decl.overloads.each do |overload|
-              func = overload.method_type.type
-              next unless func.is_a?(::RBS::Types::Function)
+          include RuboCop::Cop::RBS::Mixin::RestKeywordHash
 
-              if !func.rest_keywords.nil?
-                check_type(func.rest_keywords.type)
-              end
-            end
-          end
-
-          def check_type(type)
-            case type
-            when ::RBS::Types::ClassInstance
-              if type.name.relative!.to_s == 'Hash'
-                did_you_mean = type.args[1] or return
-                range = location_to_range(type.location)
-                message = "The type of `**` specifies only the type of value. " \
-                          "Did you mean `**#{did_you_mean}`?"
-                add_offense(range, message:)
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end

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

@@ -14,48 +14,9 @@ module RuboCop
         #   def foo: [T] (T) -> T
         #
         class UnusedOverloadTypeParams < RuboCop::RBS::CopBase
-          MSG = 'Unused overload type variable - `%<variable>s`.'
+          include RuboCop::Cop::RBS::Mixin::UnusedOverloadTypeParams
 
-          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.dup
-              map = type_params.to_h { |param| [param.name, param] }
-              type_params.each do |type_param|
-                if type_param.upper_bound
-                  used_variable_in_type(type_param.upper_bound) do |var|
-                    map.delete(var.name)
-                  end
-                end
-              end
-
-              overload.method_type.each_type do |type|
-                used_variable_in_type(type) do |var|
-                  map.delete(var.name)
-                end
-              end
-              next if map.empty?
-
-              map.each do |name, type_param|
-                next unless type_param.location
-
-                t = location_to_range(type_param.location[:name])
-                add_offense(t, message: format(MSG, variable: name))
-              end
-            end
-          end
-
-          def used_variable_in_type(type, &block)
-            case type
-            when ::RBS::Types::Variable
-              yield type
-            else
-              type.each_type do |t|
-                used_variable_in_type(t, &block)
-              end
-            end
-          end
+          alias on_rbs_def check_def
         end
       end
     end

data/lib/rubocop/cop/rbs/mixin/ambiguous_keyword_argument_key.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Mixin
+        # Shared implementation of `RBS/Lint/AmbiguousKeywordArgumentKey`
+        # and `RBSInline/Lint/AmbiguousKeywordArgumentKey`.
+        # @rbs module-self: RuboCop::Cop::Base
+        # @rbs module-self: RuboCop::RBS::CopHelper
+        module AmbiguousKeywordArgumentKey
+          #: (::RBS::AST::Members::MethodDefinition | ::RBS::AST::Ruby::Members::DefMember decl) -> void
+          def check_def(decl)
+            decl.overloads.each do |overload|
+              func = overload.method_type.type
+              next unless func.kind_of?(::RBS::Types::Function)
+              next unless !func.required_keywords.empty? || !func.optional_keywords.empty?
+
+              location = overload.method_type.location or next
+              base_pos = location.start_pos
+              lex_result = ::RBS::Parser.lex(location.source)
+              buf = []
+              lex_result.value.each do |token|
+                case token.type
+                when :pLPAREN, :pRPAREN, :tTRIVIA
+                  # skip
+                when :pCOLON
+                  next if buf.empty?
+
+                  case buf.last.type
+                  when :pQUESTION
+                    buf.shift if buf.first.type == :pQUESTION
+                    actual = buf.map { |t| t.location.source }.join
+                    did_you_mean = buf.reject { |t| t.location.source == '?' }.map { |t| t.location.source }.join
+                    message = +"`#{actual}` is not local variable name."
+                    if did_you_mean.length > 0
+                      message << " Did you mean `?#{did_you_mean}` for optional keyword argument?"
+                    end
+                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
+                    add_offense(range, message: message)
+                  when :tBANGIDENT, :tUIDENT
+                    buf.shift if buf.first.type == :pQUESTION
+                    actual = buf.map { |t| t.location.source }.join
+                    range = range_between(buf.first.location.start_pos + base_pos, buf.last.location.end_pos + base_pos)
+                    add_offense(range, message: "`#{actual}` is not local variable name.")
+                  end
+                when :pCOMMA
+                  buf.clear
+                else
+                  buf << token
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/mixin/block_return_boolish.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Mixin
+        # Shared implementation of `RBS/Style/BlockReturnBoolish` and `RBSInline/Style/BlockReturnBoolish`.
+        # @rbs module-self: RuboCop::Cop::Base
+        # @rbs module-self: RuboCop::RBS::CopHelper
+        module BlockReturnBoolish
+          MSG = 'Use `boolish` instead of `bool` in block return type.'
+
+          #: (::RBS::AST::Members::MethodDefinition | ::RBS::AST::Ruby::Members::DefMember decl) -> void
+          def check_def(decl)
+            decl.overloads.each do |overload|
+              next unless overload.method_type.block
+
+              return_type = overload.method_type.block.type.return_type
+              next unless return_type.is_a?(::RBS::Types::Bases::Bool)
+              next unless return_type.location
+
+              range = location_to_range(return_type.location)
+              add_offense(range) do |corrector|
+                corrector.replace(range, 'boolish')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/mixin/class_with_singleton.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Mixin
+        # Shared implementation of `RBS/Style/ClassWithSingleton` and `RBSInline/Style/ClassWithSingleton`.
+        # @rbs module-self: RuboCop::Cop::Base
+        # @rbs module-self: RuboCop::RBS::CopHelper
+        module ClassWithSingleton
+          MSG = 'Use `self` instead of `class`.'
+
+          #: (::RBS::AST::Members::MethodDefinition | ::RBS::AST::Ruby::Members::DefMember decl) -> void
+          def check_def(decl)
+            return unless decl.kind == :singleton
+
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          #: (::RBS::Types::t type) -> void
+          def check_type(type)
+            case type
+            when ::RBS::Types::Bases::Class
+              return unless type.location
+
+              range = location_to_range(type.location)
+              add_offense(range) do |corrector|
+                corrector.replace(range, 'self')
+              end
+            else
+              type.each_type do |t|
+                check_type(t)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/mixin/classic_type.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Mixin
+        # Shared implementation of `RBS/Style/ClassicType` and `RBSInline/Style/ClassicType`.
+        # @rbs module-self: RuboCop::Cop::Base
+        # @rbs module-self: RuboCop::RBS::CopHelper
+        module ClassicType
+          Types = ::RBS::Types #: module-alias
+
+          #: (::RBS::AST::Members::MethodDefinition | ::RBS::AST::Ruby::Members::DefMember decl) -> void
+          def check_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          #: (untyped member) -> void
+          def check_member(member)
+            type = member.type
+            check_type(type) if type&.location
+          end
+
+          #: (::RBS::Types::t type) -> untyped
+          def check_type(type)
+            find_replacement(type) do |t, replaced|
+              location = t.location or next
+
+              range = location_to_range(location)
+              add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
+                corrector.replace(range, replaced)
+              end
+            end
+          end
+
+          #: (::RBS::Types::t type) ?{ ([::RBS::Types::t, String]) -> untyped } -> untyped
+          def find_replacement(type, &block)
+            case type
+            when Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional,
+                 Types::Proc,
+                 Types::Alias,
+                 Types::Interface
+              type.each_type do |t|
+                find_replacement(t, &block)
+              end
+            when Types::ClassInstance
+              case type.name.to_s
+              when 'TrueClass', '::TrueClass'
+                block&.call([type, 'true'])
+              when 'FalseClass', '::FalseClass'
+                block&.call([type, 'false'])
+              when 'NilClass', '::NilClass'
+                block&.call([type, 'nil'])
+              end
+              type.each_type do |arg|
+                find_replacement(arg, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end