rubocop-rbs_inline 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd596a937ef29c9dd1053c9b874725aebde2e9fab387053243268810bb0a8103
-  data.tar.gz: '03865a85b9ef1783eb85816c386aee96370e48e7169994ea5cc96c1a323aacd9'
+  metadata.gz: 5f1bf0f9d17e73042a1c33ae69ffe0cf079bedb1423119b36a524d085cfe6f6a
+  data.tar.gz: '0797210c998bb891bcd07b68f3d4cc9e779cf775ea051e6529c8b052ed58642a'
 SHA512:
-  metadata.gz: a5c053242db495271ee4751bcba23bc67d876d8d668e0984634d1154452a87476ff82330ea9010c48cd0f285918124d2dc42145bb750a3a8d0f25368e8ee8e22
-  data.tar.gz: 0e78d76dc58a9ba77439f65013cf1aa46492ee84337a43c6630e81d18c02d5fba23b0fab88c42f7a73d35d3c3bf02c4cfc9bee50f9337fb4d0d2a5189ddfdbf1
+  metadata.gz: bb484322f4605db7c86dddf047de1ad1dbe477faf11b7d736edaa544132b87c1b7c0481cd13a6154662a0e318daeaf4880102882288cf02b84ba88eb8d3372f5
+  data.tar.gz: 141d659c28c9c9b2bef362b7f5b57bccf68aaec436b553e19785d97d162a0293c94d0d79ad7d29b7300f0b2583cce353c3152503ec965ab521eeff6fe3bb1127

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.7.0 (2026-07-20)
+
+### New Features
+
+- **Style/RbsInline/MissingStructClassAnnotation**: New cop that checks each attribute passed to `Struct.new` has a trailing `#:` inline type annotation. Supports autocorrect.
+- **Style/RbsInline/StructClassCommentAlignment**: New cop that checks `#:` inline type annotations in a multiline `Struct.new` call are aligned. Supports autocorrect.
+- **Style/RbsInline/StructNewWithBlock**: New cop that checks for `Struct.new` calls with a block, which RBS::Inline does not parse.
+
 ## 1.6.1 (2026-07-10)
 
 ### Bug Fixes

data/README.md

@@ -198,6 +198,32 @@ MethodEntry = Data.define(
 )
 ```
 
+### Style/RbsInline/MissingStructClassAnnotation
+
+Checks that each attribute passed to `Struct.new` has a trailing `#:` inline type annotation on the same line.
+
+For folded `Struct.new` calls (where multiple attributes share a line), the cop will suggest rewriting as a multiline call so each attribute can be annotated individually. A leading string argument (the struct name) and the `keyword_init:` keyword argument are not attributes and are ignored.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+Point = Struct.new(:x, :y)
+
+# bad - missing annotation for :y
+Point = Struct.new(
+  :x,  #: Integer
+  :y
+)
+
+# good
+Point = Struct.new(
+  :x,  #: Integer
+  :y   #: Integer
+)
+```
+
 ### Style/RbsInline/MissingTypeAnnotation
 
 Enforces that method definitions and `attr_*` declarations have RBS inline type annotations.
@@ -458,6 +484,50 @@ class Foo
 end
 ```
 
+### Style/RbsInline/StructClassCommentAlignment
+
+Checks that `#:` inline type annotations in a multiline `Struct.new` call are aligned to the same column. The expected column is determined by the longest attribute name (plus its trailing comma). Folded `Struct.new` calls (where multiple attributes share a line) are excluded.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+Point = Struct.new(
+  :x, #: Integer
+  :long_attr  #: Integer
+)
+
+# good
+Point = Struct.new(
+  :x,         #: Integer
+  :long_attr  #: Integer
+)
+```
+
+### Style/RbsInline/StructNewWithBlock
+
+Checks for `Struct.new` 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 `Struct.new` without a block and reopen the class separately to add methods.
+
+**Examples:**
+```ruby
+# bad
+User = Struct.new(:name, :role) do
+  def admin?
+    role == :admin
+  end
+end
+
+# good
+User = Struct.new(:name, :role)
+
+class User
+  def admin? #: bool
+    role == :admin
+  end
+end
+```
+
 ### Style/RbsInline/UnmatchedAnnotations
 
 Verifies that annotation parameters match the actual method parameters.

data/config/default.yml

@@ -46,6 +46,11 @@ Style/RbsInline/MissingDataClassAnnotation:
   Enabled: true
   VersionAdded: '1.5.0'
 
+Style/RbsInline/MissingStructClassAnnotation:
+  Description: "Checks that `Struct.new` attributes have inline type annotations."
+  Enabled: true
+  VersionAdded: '1.7.0'
+
 Style/RbsInline/MissingTypeAnnotation:
   Description: "Checks that method definitions and attr_* declarations have RBS inline type annotations."
   Enabled: true
@@ -94,6 +99,16 @@ Style/RbsInline/RequireRbsInlineComment:
     - always
     - never
 
+Style/RbsInline/StructClassCommentAlignment:
+  Description: "Checks that `#:` inline type annotations in `Struct.new` blocks are aligned."
+  Enabled: true
+  VersionAdded: '1.7.0'
+
+Style/RbsInline/StructNewWithBlock:
+  Description: "Checks for `Struct.new` calls with a block, which RBS::Inline does not parse."
+  Enabled: true
+  VersionAdded: '1.7.0'
+
 Style/RbsInline/UnmatchedAnnotations:
   Description: "Checks the rbs-inline annotation comment is surely matched."
   Enabled: true

data/lib/rubocop/cop/rbs_inline_cops.rb

@@ -3,6 +3,9 @@
 require_relative "style/rbs_inline/ast_utils"
 require_relative "style/rbs_inline/source_code_helper"
 require_relative "style/rbs_inline/comment_parser"
+require_relative "style/rbs_inline/data_struct_helper"
+require_relative "style/rbs_inline/missing_class_annotation"
+require_relative "style/rbs_inline/class_comment_alignment"
 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"
@@ -17,6 +20,9 @@ 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/struct_class_comment_alignment"
+require_relative "style/rbs_inline/struct_new_with_block"
+require_relative "style/rbs_inline/missing_struct_class_annotation"
 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/class_comment_alignment.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Shared behavior for cops that ensure `#:` inline type annotations on
+        # struct-like class attributes (`Data.define` / `Struct.new`) are aligned.
+        #
+        # The including cop matches the definition node (e.g. via `struct_like_class?`)
+        # and calls {#check_comment_alignment}.
+        #
+        # @rbs module-self RuboCop::Cop::Base
+        module ClassCommentAlignment
+          include DataStructHelper
+
+          # @rbs node: RuboCop::AST::SendNode
+          def check_comment_alignment(node) #: void
+            return if folded?(node)
+
+            check_annotation_alignment(node)
+          end
+
+          private
+
+          # @rbs node: RuboCop::AST::SendNode
+          def check_annotation_alignment(node) #: void
+            annotated = attr_arguments(node).filter_map do |arg|
+              comment = inline_type_comment(arg.location.line)
+              [arg, comment] if comment #: [RuboCop::AST::Node, Parser::Source::Comment]
+            end
+            return if annotated.size < 2
+
+            expected_col = annotation_column(node)
+            annotated.each do |arg, comment|
+              actual_col = comment.location.column
+              next if actual_col == expected_col
+
+              add_offense(comment.source_range) do |corrector|
+                correct_alignment(corrector, arg, comment, expected_col)
+              end
+            end
+          end
+
+          # @rbs corrector: RuboCop::Cop::Corrector
+          # @rbs arg: RuboCop::AST::Node
+          # @rbs comment: Parser::Source::Comment
+          # @rbs expected_col: Integer
+          def correct_alignment(corrector, arg, comment, expected_col) #: void # rubocop:disable Metrics/AbcSize
+            line = arg.location.line
+            line_source = source_code_at(line)
+            source = line_source[...comment.location.column] || raise
+            content_end_col = source.rstrip.length
+            padding = [expected_col - content_end_col, 1].max || raise
+
+            line_begin = processed_source.buffer.line_range(line).begin_pos
+            replace_start = line_begin + content_end_col
+            replace_end = line_begin + comment.location.column
+
+            corrector.replace(range_between(replace_start, replace_end), " " * padding)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,106 +26,25 @@ module RuboCop
         #   )
         #
         class DataClassCommentAlignment < Base
-          include ASTUtils
-          include RangeHelp
-          include SourceCodeHelper
+          include ClassCommentAlignment
           extend AutoCorrector
 
           MSG = "Misaligned inline type annotation for Data attribute."
 
           # @rbs node: RuboCop::AST::SendNode
           def on_send(node) #: void
-            return unless data_define?(node)
-            return if folded_data_class?(node)
+            return unless struct_like_class?(node)
 
-            check_annotation_alignment(node)
+            check_comment_alignment(node)
           end
 
           private
 
           # @rbs node: RuboCop::AST::SendNode
-          def data_define?(node) #: bool
+          def struct_like_class?(node) #: bool
             return false unless node.method_name == :define
 
-            case (r = node.receiver)
-            when RuboCop::AST::ConstNode
-              r.short_name == :Data
-            else
-              false
-            end
-          end
-
-          # @rbs arg: RuboCop::AST::Node
-          def data_attribute?(arg) #: bool
-            arg.sym_type? || arg.str_type?
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def data_attributes(node) #: Array[RuboCop::AST::Node]
-            node.arguments.select { data_attribute?(_1) }
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def folded_data_class?(node) #: bool
-            args = node.arguments
-            return false if args.empty?
-
-            lines = args.map { _1.location.line }
-            lines.uniq.length < args.length || lines.include?(node.location.line)
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def check_annotation_alignment(node) #: void
-            annotated = data_attributes(node).filter_map do |arg|
-              comment = inline_type_comment(arg.location.line)
-              [arg, comment] if comment #: [RuboCop::AST::Node, Parser::Source::Comment]
-            end
-            return if annotated.size < 2
-
-            expected_col = annotation_column(node)
-            annotated.each do |arg, comment|
-              actual_col = comment.location.column
-              next if actual_col == expected_col
-
-              add_offense(comment.source_range) do |corrector|
-                correct_alignment(corrector, arg, comment, expected_col)
-              end
-            end
-          end
-
-          # @rbs line: Integer
-          def inline_type_comment(line) #: Parser::Source::Comment?
-            comment = comment_at(line)
-            comment if comment&.text&.match?(/\A#:/)
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def annotation_column(node) #: Integer
-            last_arg = node.arguments.last
-            max_end_col = node.arguments.map do |arg|
-              comma_length = arg.equal?(last_arg) ? 0 : 1
-              arg.location.column + source!(arg).length + comma_length
-            end.max || 0
-
-            max_end_col + 2
-          end
-
-          # @rbs corrector: RuboCop::Cop::Corrector
-          # @rbs arg: RuboCop::AST::Node
-          # @rbs comment: Parser::Source::Comment
-          # @rbs expected_col: Integer
-          def correct_alignment(corrector, arg, comment, expected_col) #: void # rubocop:disable Metrics/AbcSize
-            line = arg.location.line
-            line_source = source_code_at(line)
-            source = line_source[...comment.location.column] || raise
-            content_end_col = source.rstrip.length
-            padding = [expected_col - content_end_col, 1].max || raise
-
-            line_begin = processed_source.buffer.line_range(line).begin_pos
-            replace_start = line_begin + content_end_col
-            replace_end = line_begin + comment.location.column
-
-            corrector.replace(range_between(replace_start, replace_end), " " * padding)
+            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Data
           end
         end
       end

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

@@ -34,7 +34,7 @@ module RuboCop
 
           # @rbs node: RuboCop::AST::SendNode
           def on_send(node) #: void
-            return unless data_define?(node)
+            return unless struct_like_class?(node)
 
             block_node = node.parent
             return unless block_node&.block_type?
@@ -45,11 +45,10 @@ module RuboCop
           private
 
           # @rbs node: RuboCop::AST::SendNode
-          def data_define?(node) #: bool
+          def struct_like_class?(node) #: bool
             return false unless node.method_name == :define
 
-            receiver = node.receiver
-            receiver.is_a?(RuboCop::AST::ConstNode) && receiver.short_name == :Data
+            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Data
           end
         end
       end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Shared logic for cops that check inline type annotations on struct-like
+        # class definitions such as `Data.define` and `Struct.new`.
+        #
+        # Including cops decide which nodes to check by defining their own matcher
+        # (e.g. `struct_like_class?`); this module only provides helpers that operate
+        # on an already-matched definition node. Cops may override {#attr_argument?}
+        # when the set of attribute arguments differs from the default (e.g.
+        # `Struct.new` treats a leading string argument as the struct name rather than
+        # an attribute).
+        #
+        # @rbs module-self RuboCop::Cop::Base
+        module DataStructHelper
+          include ASTUtils
+          include SourceCodeHelper
+          include RangeHelp
+
+          # @rbs arg: RuboCop::AST::Node
+          def attr_argument?(arg) #: bool
+            arg.sym_type? || arg.str_type?
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def attr_arguments(node) #: Array[RuboCop::AST::Node]
+            node.arguments.select { attr_argument?(_1) }
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def folded?(node) #: bool
+            attrs = attr_arguments(node)
+            return false if attrs.empty?
+
+            lines = attrs.map { _1.location.line }
+            lines.uniq.length < attrs.length || lines.include?(node.location.line)
+          end
+
+          # @rbs line: Integer
+          def inline_type_annotation?(line) #: boolish
+            comment = comment_at(line)
+            comment&.text&.match?(/\A#:/)
+          end
+
+          # @rbs line: Integer
+          def inline_type_comment(line) #: Parser::Source::Comment?
+            comment = comment_at(line)
+            comment if comment&.text&.match?(/\A#:/)
+          end
+
+          # @rbs line: Integer
+          def find_regular_comment(line) #: Parser::Source::Comment?
+            comment = comment_at(line)
+            comment unless comment&.text&.match?(/\A#:/)
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def annotation_column(node) #: Integer
+            last_arg = node.arguments.last
+            max_end_col = node.arguments.map do |arg|
+              comma_length = arg.equal?(last_arg) ? 0 : 1
+              arg.location.column + source!(arg).length + comma_length
+            end.max || 0
+
+            max_end_col + 2
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def longest_argname(node) #: String
+            last_index = node.arguments.size - 1
+            args = node.arguments.each_with_index.map { |a, i| i < last_index ? "#{a.source}," : a.source.to_s }
+            args.max_by(&:length) || ""
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def build_multiline_replacement(node) #: String # rubocop:disable Metrics/AbcSize
+            base_indent = source_code_at(node.location.line)[/\A\s*/]
+            last_index = node.arguments.size - 1
+            longest = longest_argname(node)
+
+            args_source = node.arguments.each_with_index.map do |arg, i|
+              comma = i < last_index ? "," : ""
+              prefix = "#{base_indent}  #{arg.source}#{comma}"
+              padding = " " * (longest.length - source!(arg).length - comma.length + 2)
+              attr_argument?(arg) ? "#{prefix}#{padding}#: untyped" : prefix
+            end.join("\n")
+
+            "(\n#{args_source}\n#{base_indent})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Shared behavior for cops that ensure struct-like class attributes have
+        # inline type annotations (`Data.define` / `Struct.new`).
+        #
+        # The including cop matches the definition node (e.g. via `struct_like_class?`)
+        # and calls {#check_missing_annotations}.
+        #
+        # @rbs module-self RuboCop::Cop::Base
+        module MissingClassAnnotation
+          include DataStructHelper
+
+          # @rbs node: RuboCop::AST::SendNode
+          def check_missing_annotations(node) #: void
+            if folded?(node)
+              add_offenses_for_folded(node)
+            else
+              check_multiline(node)
+            end
+          end
+
+          private
+
+          # @rbs node: RuboCop::AST::SendNode
+          def add_offenses_for_folded(node) #: void
+            corrected = false
+            attr_arguments(node).each do |arg|
+              if corrected
+                add_offense(arg)
+              else
+                replacement = build_multiline_replacement(node)
+                loc = node.loc
+                if loc.begin && loc.end
+                  add_offense(arg) { _1.replace(loc.begin.join(loc.end), replacement) }
+                  corrected = true
+                end
+              end
+            end
+          end
+
+          # @rbs node: RuboCop::AST::SendNode
+          def check_multiline(node) #: void
+            attr_arguments(node).each do |arg|
+              next if inline_type_annotation?(arg.location.line)
+
+              add_offense(arg) { correct_multiline(_1, node, arg) }
+            end
+          end
+
+          # @rbs corrector: RuboCop::Cop::Corrector
+          # @rbs node: RuboCop::AST::SendNode
+          # @rbs arg: RuboCop::AST::Node
+          def correct_multiline(corrector, node, arg) #: void
+            existing_comment = find_regular_comment(arg.location.line)
+
+            if existing_comment
+              comment_text = existing_comment.text.sub(/\A#\s*/, "")
+              corrector.replace(existing_comment.source_range, "#: untyped -- #{comment_text}")
+            else
+              insert_annotation(corrector, node, arg)
+            end
+          end
+
+          # @rbs corrector: RuboCop::Cop::Corrector
+          # @rbs node: RuboCop::AST::SendNode
+          # @rbs arg: RuboCop::AST::Node
+          def insert_annotation(corrector, node, arg) #: void
+            line = arg.location.line
+            line_source = source_code_at(line)
+            content_end_col = line_source.rstrip.length
+            padding = [annotation_column(node) - content_end_col, 1].max || raise
+            line_begin = processed_source.buffer.line_range(line).begin_pos
+            insert_pos = line_begin + content_end_col
+
+            corrector.insert_before(range_between(insert_pos, insert_pos), "#{" " * padding}#: untyped")
+          end
+        end
+      end
+    end
+  end
+end