rubocop-rbs_inline 1.5.0.pre.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 813f81c0980296d50e92c6a928f3ac51e3954748095a1e0dd6117cdcf77a8166
-  data.tar.gz: '029b0e05c922841def3501e57587045660c4d0f05752dba974797f7215661b62'
+  metadata.gz: 1d23ee9bd49cabe4e0b153c7d1423768c42172f800fecd4c8a1786dc9c110078
+  data.tar.gz: 7605f5de5e26c0ea0134f5a842503beaa49b5099ec4bf9c149a149342be15b84
 SHA512:
-  metadata.gz: 2768b2232009f4c70366981b7ffc47ef55edef17f6938f31d0740a645189a71fea2666e64edaf005cb27489ea18f2038f80c917240bc861fa8b60672e2286dbc
-  data.tar.gz: 42191af687cb627862f2ee617579df7932c65b656d35c7c4651453dc2c58106f28f73b2794107c3eb99a4d66bab141b43015072493bd19b60e3a8bc27f7d4f76
+  metadata.gz: 2cc7f50364b7bdb9db4258aadb53cc9b88e4f5c1e4de691ab0e9630df5821e91ce07d4935ef5784a09a9667d9e3042566293921f710c9312a3c0231775e7a735
+  data.tar.gz: c396f462d1d3ab5e8342595e392e65f9105e44b8c8457ad477a15415122a364969e04324c597b5d68b25c58fd43fb8bdb1fdade219951e8dce888df89d676138

data/CHANGELOG.md

@@ -1,12 +1,12 @@
 # Changelog
 
-## 1.5.0 (unreleased)
+## 1.5.0 (2026-02-24)
 
 ### New Cops
 
+- **Style/RbsInline/UntypedInstanceVariable**: Warns when an instance variable used in a class or module does not have an RBS type annotation. An instance variable is considered typed when a `# @rbs @ivar: Type` annotation exists in the class body, or when it is covered by an `attr_reader`, `attr_writer`, or `attr_accessor` declaration with an inline `#: Type` comment.
 - **Style/RbsInline/RedundantAnnotationWithSkip**: Warns when type annotations (`#:` method type signatures, `# @rbs` method types, parameter annotations, return type annotations, or trailing inline types) are present alongside `# @rbs skip` or `# @rbs override`. These directives skip RBS generation, making any additional type annotations redundant. Supports unsafe autocorrect.
-- **Style/RbsInline/RedundantReturnType**: Warns when both a `# @rbs return` comment and a `#:` annotation comment specify the return type for the same method. The `EnforcedStyle` option accepts `inline_comment` (prefer `#:`) or `rbs_return_comment` (prefer `# @rbs return`). Supports safe autocorrect.
-- **Style/RbsInline/RedundantArgumentType**: Warns when both a `# @rbs param` comment and a `#:` annotation comment specify the argument type for the same method. The `EnforcedStyle` option accepts `annotation_comment` or `rbs_param_comment` (default). Supports autocorrect when `annotation_comment` style is preferred.
+- **Style/RbsInline/RedundantTypeAnnotation**: Warns when redundant type annotations exist for the same method definition. Detects conflicts between `#:` method type signatures, `# @rbs param:` annotations, `# @rbs return:` annotations, and trailing inline `#:` return types. The `EnforcedStyle` option accepts `method_type_signature` (prefer `#:` signatures), `doc_style` (prefer `# @rbs` annotations), or `doc_style_and_return_annotation` (prefer `# @rbs` params with trailing `#:` return type, default: `doc_style`). Supports unsafe autocorrect.
 - **Style/RbsInline/MissingTypeAnnotation**: Warns when a method definition has no type annotation. The `Visibility` option narrows the target methods by visibility (default: `all`).
 - **Style/RbsInline/RequireRbsInlineComment**: Enforces the presence or absence of a `# rbs_inline:` magic comment. The `EnforcedStyle` option accepts `always` (default, requires the comment) or `never` (forbids the comment).
 - **Style/RbsInline/EmbeddedRbsSpacing**: Warns when a `@rbs!` embedded RBS comment block is not followed by a blank line. Supports autocorrect.
@@ -14,6 +14,8 @@
 - **Style/RbsInline/MethodCommentSpacing**: Warns when a method-related `@rbs` annotation (`param`, `return`, `&block`, `override`, `skip`, etc.) is not placed immediately before the method definition it describes.
 - **Style/RbsInline/MissingDataClassAnnotation**: Warns when an attribute passed to `Data.define` does not have a trailing `#:` inline type annotation. Supports autocorrect.
 - **Style/RbsInline/DataClassCommentAlignment**: Warns when the `#:` inline type annotation comments in a multiline `Data.define` block are not aligned to the same column. Supports autocorrect.
+- **Style/RbsInline/DataDefineWithBlock**: Warns when `Data.define` is called with a block. RBS::Inline does not parse block contents, so methods defined inside will not be recognized. Users should call `Data.define` without a block and reopen the class separately to add methods.
+- **Style/RbsInline/RedundantInstanceVariableAnnotation**: Warns when a `# @rbs @ivar: Type` instance variable type annotation is redundant because an `attr_*` with an inline type annotation already exists for the same attribute. Supports autocorrect.
 
 ### Enhancements
 

data/README.md

@@ -27,6 +27,52 @@ plugins:
 
 rubocop-rbs_inline provides the following cops to validate [RBS::Inline](https://github.com/soutaro/rbs-inline) annotations:
 
+### Style/RbsInline/DataClassCommentAlignment
+
+Checks that `#:` inline type annotations in a multiline `Data.define` call are aligned to the same column. The expected column is determined by the longest attribute name (plus its trailing comma). Folded `Data.define` calls (where multiple attributes share a line) are excluded.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+MethodEntry = Data.define(
+  :name, #: Symbol
+  :node,       #: Parser::AST::Node
+  :visibility  #: Symbol
+)
+
+# good
+MethodEntry = Data.define(
+  :name,       #: Symbol
+  :node,       #: Parser::AST::Node
+  :visibility  #: Symbol
+)
+```
+
+### Style/RbsInline/DataDefineWithBlock
+
+Checks for `Data.define` calls with a block. RBS::Inline does not parse block contents, so any methods defined inside the block will not be recognized for type checking. Instead, call `Data.define` without a block and reopen the class separately to add methods.
+
+**Examples:**
+```ruby
+# bad
+User = Data.define(:name, :role) do
+  def admin?
+    role == :admin
+  end
+end
+
+# good
+User = Data.define(:name, :role)
+
+class User
+  def admin? #: bool
+    role == :admin
+  end
+end
+```
+
 ### Style/RbsInline/EmbeddedRbsSpacing
 
 Checks that `@rbs!` comments (embedded RBS) are followed by a blank line.
@@ -91,6 +137,67 @@ Ensures RBS keywords (`module-self`, `inherits`, `override`, etc.) are not follo
 # @rbs module-self String
 ```
 
+### Style/RbsInline/MethodCommentSpacing
+
+Checks that method-related `@rbs` annotations are placed immediately before their method definition, with no blank lines in between. Also flags method-related annotations that are not followed by a method definition at all.
+
+Method-related annotations include `# @rbs param:`, `# @rbs return:`, `# @rbs &block:`, `# @rbs override`, `# @rbs skip`, `# @rbs %a{...}`, `# @rbs (...) -> Type`, and `#: (...) -> Type`.
+
+Supports autocorrect (removes blank lines between the annotation and the method definition).
+
+**Examples:**
+```ruby
+# bad - blank line between annotation and method
+# @rbs x: Integer
+# @rbs return: String
+
+def method(x)
+end
+
+# bad - annotation comment not followed by a method definition
+# @rbs x: Integer
+puts "something"
+
+# good
+# @rbs x: Integer
+# @rbs return: String
+def method(x)
+end
+
+# good
+#: (Integer) -> String
+def method(x)
+end
+```
+
+### Style/RbsInline/MissingDataClassAnnotation
+
+Checks that each attribute passed to `Data.define` has a trailing `#:` inline type annotation on the same line.
+
+For folded `Data.define` calls (where multiple attributes share a line), the cop will suggest rewriting as a multiline call so each attribute can be annotated individually.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+MethodEntry = Data.define(:name, :node, :visibility)
+
+# bad - missing annotation for :node
+MethodEntry = Data.define(
+  :name,       #: Symbol
+  :node,
+  :visibility  #: Symbol
+)
+
+# good
+MethodEntry = Data.define(
+  :name,       #: Symbol
+  :node,       #: Parser::AST::Node
+  :visibility  #: Symbol
+)
+```
+
 ### Style/RbsInline/MissingTypeAnnotation
 
 Enforces that method definitions and `attr_*` declarations have RBS inline type annotations.
@@ -208,86 +315,95 @@ def method(a)
 end
 ```
 
-### Style/RbsInline/RedundantArgumentType
+### Style/RbsInline/RedundantInstanceVariableAnnotation
 
-Detects redundant argument type specifications when both `#:` annotation comments and `# @rbs` parameter comments exist.
+Warns when a `# @rbs @ivar: Type` instance variable type annotation is redundant because an `attr_*` with an inline type annotation already exists for the same attribute.
 
-**Configuration:** `EnforcedStyle` (default: `doc_style`)
-- `method_type_signature`: Prefers `#:` annotation comments with parameter types
-- `doc_style`: Prefers `# @rbs param:` annotations
+Supports autocorrect (removes the redundant instance variable type annotation).
 
-**Examples (EnforcedStyle: doc_style):**
+**Examples:**
 ```ruby
-# bad - both annotation comment and @rbs param
-# @rbs a: Integer
-#: (Integer) -> void
-def method(a)
-end
+# bad
+# @rbs @foo: Integer
+
+attr_reader :foo #: Integer
 
 # good
-# @rbs a: Integer
-def method(a) #: void
-end
+attr_reader :foo #: Integer
+
+# good - no inline annotation, so ivar annotation is not redundant
+# @rbs @foo: Integer
+
+attr_reader :foo
 ```
 
+### Style/RbsInline/RedundantTypeAnnotation
+
+Detects redundant type annotations when multiple type specifications exist for the same method. This covers both redundant argument type annotations (when both `#:` and `# @rbs param` specify the same parameter) and redundant return type annotations (when multiple of `#:`, trailing `#:`, and `# @rbs return` specify the return type).
+
+Supports unsafe autocorrect.
+
+**Configuration:** `EnforcedStyle` (default: `doc_style`)
+- `method_type_signature`: Prefers `#:` annotation comments with the full method signature; `# @rbs param:` and `# @rbs return:` annotations alongside a `#:` signature are redundant
+- `doc_style`: Prefers `# @rbs` annotations; `#:` method type signatures alongside `# @rbs` annotations are redundant
+- `doc_style_and_return_annotation`: Prefers `# @rbs param:` annotations with a trailing inline `#:` return type; full `#:` signatures and `# @rbs return:` annotations are redundant
+
 **Examples (EnforcedStyle: method_type_signature):**
 ```ruby
-# bad - both annotation comment and @rbs param
+# bad - redundant @rbs parameter annotation
 # @rbs a: Integer
 #: (Integer) -> void
 def method(a)
 end
 
-# good
-#: (Integer) -> void
-def method(a)
-end
-```
-
-### Style/RbsInline/RedundantReturnType
-
-Detects redundant return type specifications when multiple return type annotations exist.
-
-**Configuration:** `EnforcedStyle` (default: `return_type_annotation`)
-- `method_type_signature`: Prefers `#:` annotation comments before the method
-- `return_type_annotation`: Prefers inline `#:` return type on the def line
-- `doc_style`: Prefers `# @rbs return:` annotations
-
-**Examples (EnforcedStyle: return_type_annotation):**
-```ruby
-# bad - multiple return type specifications
+# bad - redundant trailing return type
 #: () -> String
 def method(arg) #: String
 end
 
-# good - single inline return type
-def method(arg) #: String
+# good
+#: (Integer) -> String
+def method(a)
 end
 ```
 
-**Examples (EnforcedStyle: method_type_signature):**
+**Examples (EnforcedStyle: doc_style):**
 ```ruby
-# bad - multiple return type specifications
-#: () -> String
+# bad - redundant #: method type signature
+# @rbs a: Integer
+#: (Integer) -> void
+def method(a)
+end
+
+# bad - redundant trailing return type
+# @rbs return: String
 def method(arg) #: String
 end
 
-# good - annotation comment with return type
-#: () -> String
-def method(arg)
+# good
+# @rbs a: Integer
+# @rbs return: String
+def method(a)
 end
 ```
 
-**Examples (EnforcedStyle: doc_style):**
+**Examples (EnforcedStyle: doc_style_and_return_annotation):**
 ```ruby
-# bad - multiple return type specifications
-# @rbs return: String
-def method(arg) #: String
+# bad - redundant #: method type signature
+# @rbs a: Integer
+#: (Integer) -> String
+def method(a)
 end
 
-# good - @rbs return annotation
+# bad - redundant @rbs return annotation
+# @rbs a: Integer
 # @rbs return: String
-def method(arg)
+def method(a) #: String
+end
+
+# good
+# @rbs a: Integer
+def method(a) #: String
 end
 ```
 
@@ -326,16 +442,69 @@ def method(arg); end
 def method(arg); end
 ```
 
+### Style/RbsInline/UntypedInstanceVariable
+
+Warns when an instance variable used in a class or module does not have an RBS type annotation. An instance variable is considered typed when a `# @rbs @ivar: Type` annotation exists in the class body, or when it is covered by an `attr_reader`, `attr_writer`, or `attr_accessor` declaration with an inline `#: Type` comment.
+
+**Examples:**
+```ruby
+# bad
+class Foo
+  def bar
+    @baz
+  end
+end
+
+# good
+class Foo
+  # @rbs @baz: Integer
+
+  def bar
+    @baz
+  end
+end
+
+# good
+class Foo
+  attr_reader :baz  #: Integer
+
+  def bar
+    @baz
+  end
+end
+```
+
+### Style/RbsInline/VariableCommentSpacing
+
+Checks that `@rbs` variable comments for instance variables (`@ivar`), class variables (`@@cvar`), and class instance variables (`self.@civar`) are followed by a blank line. RBS::Inline requires these comments to be standalone, so code must not immediately follow them.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+# @rbs @ivar: Integer
+# @rbs @@cvar: Float
+# @rbs self.@civar: String
+def method
+end
+
+# good
+# @rbs @ivar: Integer
+# @rbs @@cvar: Float
+# @rbs self.@civar: String
+
+def method
+end
+```
+
 ## Configuration
 
 You can customize cop behavior in your `.rubocop.yml`. For example:
 
 ```yaml
 # Prefer method type signatures over doc-style annotations
-Style/RbsInline/RedundantArgumentType:
-  EnforcedStyle: method_type_signature
-
-Style/RbsInline/RedundantReturnType:
+Style/RbsInline/RedundantTypeAnnotation:
   EnforcedStyle: method_type_signature
 
 # Only require annotations on public methods

data/config/default.yml

@@ -3,8 +3,8 @@ Style/RbsInline/DataClassCommentAlignment:
   Enabled: true
   VersionAdded: '1.5.0'
 
-Style/RbsInline/MissingDataClassAnnotation:
-  Description: "Checks that `Data.define` attributes have inline type annotations."
+Style/RbsInline/DataDefineWithBlock:
+  Description: "Checks for `Data.define` calls with a block, which RBS::Inline does not parse."
   Enabled: true
   VersionAdded: '1.5.0'
 
@@ -23,11 +23,21 @@ Style/RbsInline/InvalidTypes:
   Enabled: true
   VersionAdded: "1.0.0"
 
+Style/RbsInline/KeywordSeparator:
+  Description: "Checks the rbs-inline annotation comment does not use a separator after the keywords."
+  Enabled: true
+  VersionAdded: "1.0.0"
+
 Style/RbsInline/MethodCommentSpacing:
   Description: 'Checks that method-related `@rbs` annotations are placed immediately before method definitions.'
   Enabled: true
   VersionAdded: '1.5.0'
 
+Style/RbsInline/MissingDataClassAnnotation:
+  Description: "Checks that `Data.define` attributes have inline type annotations."
+  Enabled: true
+  VersionAdded: '1.5.0'
+
 Style/RbsInline/MissingTypeAnnotation:
   Description: "Checks that method definitions and attr_* declarations have RBS inline type annotations."
   Enabled: true
@@ -39,11 +49,6 @@ Style/RbsInline/MissingTypeAnnotation:
     - doc_style_and_return_annotation
   Visibility: all
 
-Style/RbsInline/KeywordSeparator:
-  Description: "Checks the rbs-inline annotation comment does not use a separator after the keywords."
-  Enabled: true
-  VersionAdded: "1.0.0"
-
 Style/RbsInline/ParametersSeparator:
   Description: "Checks the rbs-inline annotation comment uses a separator to parameters"
   Enabled: true
@@ -55,6 +60,11 @@ Style/RbsInline/RedundantAnnotationWithSkip:
   SafeAutoCorrect: false
   VersionAdded: '1.5.0'
 
+Style/RbsInline/RedundantInstanceVariableAnnotation:
+  Description: "Checks for redundant `@rbs` instance variable type annotation when `attr_*` with an inline type annotation is already defined."
+  Enabled: true
+  VersionAdded: '1.5.0'
+
 Style/RbsInline/RedundantTypeAnnotation:
   Description: "Checks for redundant type annotations when multiple type specifications exist for the same method definition."
   Enabled: true
@@ -80,6 +90,11 @@ Style/RbsInline/UnmatchedAnnotations:
   Enabled: true
   VersionAdded: "1.0.0"
 
+Style/RbsInline/UntypedInstanceVariable:
+  Description: "Checks that instance variables in classes/modules have RBS type annotations."
+  Enabled: true
+  VersionAdded: '1.5.0'
+
 Style/RbsInline/VariableCommentSpacing:
   Description: 'Checks that `@rbs` variable comments are followed by a blank line.'
   Enabled: true

data/lib/rubocop/cop/rbs_inline_cops.rb

@@ -2,17 +2,20 @@
 
 require_relative 'style/rbs_inline/source_code_helper'
 require_relative 'style/rbs_inline/comment_parser'
+require_relative 'style/rbs_inline/data_class_comment_alignment'
+require_relative 'style/rbs_inline/data_define_with_block'
 require_relative 'style/rbs_inline/embedded_rbs_spacing'
 require_relative 'style/rbs_inline/invalid_comment'
 require_relative 'style/rbs_inline/invalid_types'
 require_relative 'style/rbs_inline/keyword_separator'
 require_relative 'style/rbs_inline/method_comment_spacing'
-require_relative 'style/rbs_inline/data_class_comment_alignment'
 require_relative 'style/rbs_inline/missing_data_class_annotation'
 require_relative 'style/rbs_inline/missing_type_annotation'
 require_relative 'style/rbs_inline/parameters_separator'
 require_relative 'style/rbs_inline/redundant_annotation_with_skip'
+require_relative 'style/rbs_inline/redundant_instance_variable_annotation'
 require_relative 'style/rbs_inline/redundant_type_annotation'
 require_relative 'style/rbs_inline/require_rbs_inline_comment'
 require_relative 'style/rbs_inline/unmatched_annotations'
+require_relative 'style/rbs_inline/untyped_instance_variable'
 require_relative 'style/rbs_inline/variable_comment_spacing'

data/lib/rubocop/cop/style/rbs_inline/comment_parser.rb

@@ -80,14 +80,17 @@ module RuboCop
 
           # Find @rbs parameter annotations before a method definition
           # @rbs def_line: Integer
-          def find_doc_style_param_annotations(def_line) #: Array[RBS::Inline::AST::Annotations::VarType | RBS::Inline::AST::Annotations::BlockType]?
+          # rubocop:disable Layout/LineLength
+          def find_doc_style_param_annotations(def_line) #: Array[RBS::Inline::AST::Annotations::VarType | RBS::Inline::AST::Annotations::BlockType | RBS::Inline::AST::Annotations::SplatParamType | RBS::Inline::AST::Annotations::DoubleSplatParamType]?
+            # rubocop:enable Layout/LineLength
             leading_annotation = find_leading_annotation(def_line)
             return unless leading_annotation
 
-            annotations = [] #: Array[RBS::Inline::AST::Annotations::VarType | RBS::Inline::AST::Annotations::BlockType]
+            annotations = [] #: Array[RBS::Inline::AST::Annotations::VarType | RBS::Inline::AST::Annotations::BlockType | RBS::Inline::AST::Annotations::SplatParamType | RBS::Inline::AST::Annotations::DoubleSplatParamType] # rubocop:disable Layout/LineLength
             leading_annotation.each_annotation do |annotation|
               case annotation
-              when RBS::Inline::AST::Annotations::VarType, RBS::Inline::AST::Annotations::BlockType
+              when RBS::Inline::AST::Annotations::VarType, RBS::Inline::AST::Annotations::BlockType,
+                   RBS::Inline::AST::Annotations::SplatParamType, RBS::Inline::AST::Annotations::DoubleSplatParamType
                 annotations << annotation
               end
             end

data/lib/rubocop/cop/style/rbs_inline/data_define_with_block.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Checks for `Data.define` calls with a block.
+        #
+        # RBS::Inline does not parse the contents of `Data.define` blocks, so any
+        # methods defined inside will not be recognized for type checking. Instead,
+        # call `Data.define` without a block and define additional methods by
+        # reopening the class separately.
+        #
+        # NOTE: This is a known limitation of RBS::Inline. See
+        # https://github.com/soutaro/rbs-inline/pull/183 for the upstream fix.
+        #
+        # @example
+        #   # bad
+        #   User = Data.define(:name, :role) do
+        #     def admin? = role == :admin #: bool
+        #   end
+        #
+        #   # good
+        #   User = Data.define(:name, :role)
+        #
+        #   class User
+        #     def admin? = role == :admin #: bool
+        #   end
+        #
+        class DataDefineWithBlock < Base
+          MSG = 'Do not use `Data.define` with a block. RBS::Inline does not parse block contents, ' \
+                'so methods defined in the block will not be recognized. ' \
+                'Use a separate class definition instead.'
+
+          # @rbs node: RuboCop::AST::SendNode
+          def on_send(node) #: void
+            return unless data_define?(node)
+
+            block_node = node.parent
+            return unless block_node&.block_type?
+
+            add_offense(node)
+          end
+
+          private
+
+          # @rbs node: RuboCop::AST::SendNode
+          def data_define?(node) #: bool
+            return false unless node.method_name == :define
+
+            receiver = node.receiver
+            receiver.is_a?(RuboCop::AST::ConstNode) && receiver.short_name == :Data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/rbs_inline/keyword_separator.rb

@@ -29,6 +29,8 @@ module RuboCop
           # Only `# @rbs override: SomeType` (with a type) is valid as a parameter annotation.
           NO_ARGUMENT_KEYWORDS = %w[override skip].freeze #: Array[String]
 
+          # @rbs @method_annotation_lines: Set[Integer]
+
           def on_new_investigation #: void
             super
             parse_comments