rubocop-rbs_inline 1.7.0 → 1.8.0

data/lib/rubocop/cop/style/rbs_inline/{comment_parser.rb → mixin/comment_parser.rb}

@@ -13,8 +13,16 @@ module RuboCop
         module CommentParser
           attr_reader :parsed_comments #: Array[RBS::Inline::AnnotationParser::ParsingResult]
 
+          # Fallback for cops that include CommentParser without prepending FileFilter;
+          # `FileFilter` overrides this to return the real per-file decision.
+          def rbs_inline_file_skipped? #: bool
+            false
+          end
+
           # Parse comments from the source code
           def parse_comments #: Array[RBS::Inline::AnnotationParser::ParsingResult]
+            return @parsed_comments = [] if rbs_inline_file_skipped?
+
             parsed_result = Prism.parse(processed_source.buffer.source)
             @parsed_comments = RBS::Inline::AnnotationParser.parse(parsed_result.comments)
           end

data/lib/rubocop/cop/style/rbs_inline/mixin/data_class_matcher.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Matcher for `Data.define` calls, shared by the cops that check
+        # `Data.define` class definitions.
+        module DataClassMatcher
+          private
+
+          # @rbs node: RuboCop::AST::SendNode
+          def struct_like_class?(node) #: bool
+            return false unless node.method_name == :define
+
+            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/rbs_inline/{data_struct_helper.rb → mixin/data_struct_helper.rb}

@@ -57,10 +57,13 @@ module RuboCop
             comment unless comment&.text&.match?(/\A#:/)
           end
 
+          # The column is determined by the attribute arguments only; non-attribute
+          # arguments (e.g. the `Struct.new` name or a `keyword_init:` keyword argument)
+          # never carry an annotation and so must not influence the alignment.
           # @rbs node: RuboCop::AST::SendNode
           def annotation_column(node) #: Integer
             last_arg = node.arguments.last
-            max_end_col = node.arguments.map do |arg|
+            max_end_col = attr_arguments(node).map do |arg|
               comma_length = arg.equal?(last_arg) ? 0 : 1
               arg.location.column + source!(arg).length + comma_length
             end.max || 0
@@ -68,10 +71,12 @@ module RuboCop
             max_end_col + 2
           end
 
+          # Only attribute arguments are considered, for the same reason as
+          # {#annotation_column}.
           # @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 }
+            last_arg = node.arguments.last
+            args = attr_arguments(node).map { _1.equal?(last_arg) ? _1.source.to_s : "#{_1.source}," }
             args.max_by(&:length) || ""
           end
 
@@ -84,8 +89,12 @@ module RuboCop
             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
+              if attr_argument?(arg)
+                padding = " " * (longest.length - source!(arg).length - comma.length + 2)
+                "#{prefix}#{padding}#: untyped"
+              else
+                prefix
+              end
             end.join("\n")
 
             "(\n#{args_source}\n#{base_indent})"

data/lib/rubocop/cop/style/rbs_inline/mixin/file_filter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Filters files a cop reports offenses on, based on `Mode` configuration.
+        #
+        # When `Mode` is `opt_in`, offenses are only reported for files that contain
+        # a `# rbs_inline: enabled` magic comment. When `Mode` is `opt_out`, all files
+        # are checked unless they contain `# rbs_inline: disabled`. When `Mode` is not
+        # set, all files are checked (legacy behavior).
+        #
+        # This module is designed to be `prepend`ed to a cop so that it can short-circuit
+        # the cop's heavy work (annotation parsing via `parse_comments`) and suppress any
+        # residual offense reporting for files that should be skipped.
+        #
+        # @rbs module-self RuboCop::Cop::Base
+        module FileFilter
+          # @rbs! type mode = :opt_in | :opt_out
+
+          MAGIC_COMMENT_ENABLED  = /\A# rbs_inline: enabled\R?\z/ #: Regexp
+          MAGIC_COMMENT_DISABLED = /\A# rbs_inline: disabled\R?\z/ #: Regexp
+
+          SUPPORTED_MODES = %i[opt_in opt_out].freeze #: Array[mode]
+
+          # Tracks Mode values that have already been reported as invalid, so we
+          # only emit one warning per typo across the whole rubocop run instead of
+          # one per (file × cop).
+          # @rbs self.@warned_invalid_modes: Hash[String, bool]
+
+          @warned_invalid_modes = {} # rubocop:disable Style/RbsInline/UntypedInstanceVariable
+
+          # @rbs raw: untyped
+          def self.warn_invalid_mode(raw) #: void
+            key = raw.to_s
+            return if @warned_invalid_modes[key]
+
+            @warned_invalid_modes[key] = true
+            Kernel.warn(
+              "[rubocop-rbs_inline] Style/RbsInline Mode #{raw.inspect} is not supported. " \
+              "Expected one of: #{SUPPORTED_MODES.join(", ")}. Filtering is disabled for this run."
+            )
+          end
+
+          # @rbs @rbs_inline_skip_file: bool
+
+          def on_new_investigation #: void
+            @rbs_inline_skip_file = skip_by_mode?
+            super
+          end
+
+          # @rbs *args: untyped
+          # @rbs **kwargs: untyped
+          def add_offense(*args, **kwargs, &) #: void
+            return if @rbs_inline_skip_file
+
+            super
+          end
+
+          # Exposes the FileFilter's per-file skip decision as a proper method so
+          # helper modules (e.g. `CommentParser`) can consult it explicitly instead
+          # of poking at `@rbs_inline_skip_file` directly.
+          def rbs_inline_file_skipped? #: bool
+            @rbs_inline_skip_file == true
+          end
+
+          private
+
+          def skip_by_mode? #: bool
+            mode = configured_mode
+            return false if mode.nil?
+
+            # `# rbs_inline: disabled` always opts a file out, regardless of Mode
+            # (matches rbs-inline itself: rbs-inline skips disabled files in both
+            # opt_in and opt_out modes).
+            return true if rbs_inline_disabled?
+
+            mode == :opt_in && !rbs_inline_enabled?
+          end
+
+          def configured_mode #: mode?
+            raw = cop_config["Mode"]
+            return nil if raw.nil?
+
+            # `raw.to_s.to_sym` handles YAML-native Integer / Boolean without
+            # raising NoMethodError on the plain `to_sym`.
+            mode = raw.to_s.to_sym
+            return mode if SUPPORTED_MODES.include?(mode)
+
+            FileFilter.warn_invalid_mode(raw)
+            nil
+          end
+
+          # Iterate the already-materialized `processed_source.comments` so this
+          # matches RequireRbsInlineComment's detection exactly (line endings,
+          # indented comments, heredoc/string content are all handled correctly
+          # by the parser).
+          def rbs_inline_enabled? #: bool
+            processed_source.comments.any? { _1.text.match?(MAGIC_COMMENT_ENABLED) }
+          end
+
+          def rbs_inline_disabled? #: bool
+            processed_source.comments.any? { _1.text.match?(MAGIC_COMMENT_DISABLED) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/rbs_inline/{source_code_helper.rb → mixin/source_code_helper.rb}

@@ -12,11 +12,9 @@ module RuboCop
           # Convert byte offset to character offset
           # @rbs byte_offset: Integer
           def character_offset(byte_offset) #: Integer
-            source = processed_source.buffer.source.dup.force_encoding("ASCII")
-            text = source[...byte_offset] or raise
-            text.force_encoding(processed_source.buffer.source.encoding).size
-          rescue StandardError
-            byte_offset
+            source = processed_source.buffer.source
+            prefix = source.byteslice(0, byte_offset) or raise
+            prefix.size
           end
 
           # @rbs pos: Integer

data/lib/rubocop/cop/style/rbs_inline/mixin/struct_class_matcher.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      module RbsInline
+        # Matcher for `Struct.new` calls, shared by the cops that check `Struct.new`
+        # class definitions.
+        #
+        # Also overrides {DataStructHelper#attr_argument?} for `Struct.new` semantics,
+        # so cops that include both must include this module last.
+        module StructClassMatcher
+          private
+
+          # @rbs node: RuboCop::AST::SendNode
+          def struct_like_class?(node) #: bool
+            return false unless node.method_name == :new
+
+            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Struct
+          end
+
+          # `Struct.new` treats a leading string argument as the struct name, so only
+          # symbol arguments are attributes.
+          # @rbs arg: RuboCop::AST::Node
+          def attr_argument?(arg) #: bool
+            arg.sym_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,13 +20,13 @@ module RuboCop
         #   # good
         #   # @rbs %a{pure}
         class ParametersSeparator < Base
+          prepend FileFilter
           extend AutoCorrector
+          include AnnotationKeywords
           include RangeHelp
 
           MSG = "Use `:` as a separator between parameter name and type."
 
-          # refs: https://github.com/soutaro/rbs-inline/blob/main/lib/rbs/inline/annotation_parser/tokenizer.rb
-          RBS_INLINE_KEYWORDS = %w[inherits override use module-self generic skip module class].freeze #: Array[String]
           RBS_INLINE_REGEXP_KEYWORDS = [/%a{(\w|-)+}/, /%a\((\w|-)+\)/, /%a\[(\w|-)+\]/].freeze #: Array[Regexp]
 
           def on_new_investigation #: void

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

@@ -58,7 +58,9 @@ module RuboCop
         #   end
         #
         class RedundantAnnotationWithSkip < Base
+          prepend FileFilter
           extend AutoCorrector
+          include ASTUtils
           include CommentParser
           include RangeHelp
           include SourceCodeHelper
@@ -182,17 +184,6 @@ module RuboCop
               corrector.remove(removal_range)
             end
           end
-
-          # Returns the last line of the method parameter list (the closing ) line, or the def line if no parens).
-          # @rbs node: RuboCop::AST::DefNode
-          def method_parameter_list_end_line(node) #: Integer
-            args_node = case node.type
-                        when :def  then node.children[1]
-                        when :defs then node.children[2]
-                        else raise
-                        end
-            args_node.location.end&.line || node.location.line
-          end
         end
       end
     end

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

@@ -28,6 +28,7 @@ module RuboCop
         #   attr_reader :foo
         #
         class RedundantInstanceVariableAnnotation < Base
+          prepend FileFilter
           extend AutoCorrector
           include ASTUtils
           include CommentParser

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

@@ -80,7 +80,9 @@ module RuboCop
         #   end
         #
         class RedundantTypeAnnotation < Base
+          prepend FileFilter
           extend AutoCorrector
+          include ASTUtils
           include CommentParser
           include ConfigurableEnforcedStyle
           include RangeHelp
@@ -129,17 +131,6 @@ module RuboCop
             end
           end
 
-          # Returns the last line of the method parameter list (the closing ) line, or the def line if no parens).
-          # @rbs node: RuboCop::AST::DefNode
-          def method_parameter_list_end_line(node) #: Integer
-            args_node = case node.type
-                        when :def  then node.children[1]
-                        when :defs then node.children[2]
-                        else raise
-                        end
-            args_node.location.end&.line || node.location.line
-          end
-
           # @rbs def_line: Integer
           # @rbs parameter_list_end_line: Integer
           def check_return_type_redundancy(def_line, parameter_list_end_line) #: void
@@ -165,7 +156,7 @@ module RuboCop
             last = comments.last or return
             range = first.loc.expression.join(last.loc.expression)
             add_offense(range, message: MSG_METHOD_TYPE_SIGNATURE) do |corrector|
-              unexpected_style_detected(:method_type_signature)
+              no_acceptable_style!
               corrector.remove(range_by_whole_lines(range, include_final_newline: true))
             end
           end
@@ -178,7 +169,7 @@ module RuboCop
           def add_offense_for_doc_style_param(annotation) #: void
             range = annotation_range(annotation) or return
             add_offense(range, message: MSG_DOC_STYLE_PARAM) do |corrector|
-              unexpected_style_detected(:doc_style)
+              no_acceptable_style!
               corrector.remove(range_by_whole_lines(range, include_final_newline: true))
             end
           end
@@ -199,7 +190,7 @@ module RuboCop
           # @rbs comment: Parser::Source::Comment
           def add_offense_for_trailing_return(comment) #: void
             add_offense(comment, message: MSG_TRAILING_RETURN) do |corrector|
-              unexpected_style_detected(:return_type_annotation)
+              no_acceptable_style!
               removal_range = range_with_surrounding_space(range: comment.loc.expression, side: :left, newlines: false)
               corrector.remove(removal_range)
             end
@@ -209,7 +200,7 @@ module RuboCop
           def add_offense_for_doc_style_return(annotation) #: void
             range = annotation_range(annotation) or return
             add_offense(range, message: MSG_DOC_STYLE_RETURN) do |corrector|
-              unexpected_style_detected(:doc_style)
+              no_acceptable_style!
               corrector.remove(range_by_whole_lines(range, include_final_newline: true))
             end
           end

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

@@ -10,7 +10,7 @@ module RuboCop
         # opt-out (processes all files by default). This cop enforces consistency in which
         # mode your codebase uses.
         #
-        # @example EnforcedStyle: always (default)
+        # @example Mode: opt_in
         #   # bad
         #   # (no rbs_inline comment)
         #   class Foo
@@ -26,7 +26,17 @@ module RuboCop
         #   class Foo
         #   end
         #
-        # @example EnforcedStyle: never
+        # @example Mode: opt_in, AllowMissingComment: true
+        #   # good - the cop does not enforce the magic comment
+        #   class Foo
+        #   end
+        #
+        #   # good
+        #   # rbs_inline: enabled
+        #   class Foo
+        #   end
+        #
+        # @example Mode: opt_out
         #   # bad
         #   # rbs_inline: enabled
         #   class Foo
@@ -49,16 +59,29 @@ module RuboCop
           MSG_MISSING = "Missing `# rbs_inline:` magic comment."
           MSG_FORBIDDEN = "Remove `# rbs_inline:` magic comment."
 
+          # @rbs self.@enforced_style_deprecation_warned: bool
+
+          @enforced_style_deprecation_warned = false # rubocop:disable Style/RbsInline/UntypedInstanceVariable
+
+          def self.enforced_style_deprecation_warned? #: bool
+            @enforced_style_deprecation_warned == true
+          end
+
+          def self.mark_enforced_style_deprecation_warned! #: void
+            @enforced_style_deprecation_warned = true
+          end
+
           def on_new_investigation #: void
             return if processed_source.buffer.source.empty?
 
+            warn_deprecated_enforced_style
+
             magic_comment = find_rbs_inline_magic_comment
             return if disabled?(magic_comment)
 
-            if style == :always
-              check_always_style(magic_comment)
-            elsif style == :never
-              check_never_style(magic_comment)
+            case effective_mode
+            when :opt_in then check_opt_in(magic_comment)
+            when :opt_out then check_opt_out(magic_comment)
             end
           end
 
@@ -76,41 +99,45 @@ module RuboCop
           end
 
           # @rbs magic_comment: Parser::Source::Comment?
-          def check_always_style(magic_comment) #: void
-            # disabled is already filtered out by early return
-            # magic_comment is either nil or enabled
+          def check_opt_in(magic_comment) #: void
             return if magic_comment
+            return if allow_missing_comment?
 
-            # Insert after the first comment block or at the beginning of the file
             insert_position = find_insert_position
             add_offense(first_line_range, message: MSG_MISSING) do |corrector|
               insert_range = Parser::Source::Range.new(processed_source.buffer, insert_position, insert_position)
-              corrector.insert_before(insert_range, "# rbs_inline: enabled\n")
+              corrector.insert_before(insert_range, insertion_text(insert_position))
             end
           end
 
           # @rbs magic_comment: Parser::Source::Comment?
-          def check_never_style(magic_comment) #: void
-            # disabled is already filtered out by early return
-            # magic_comment is either nil or enabled
+          def check_opt_out(magic_comment) #: void
             return unless magic_comment
 
             add_offense(magic_comment.source_range, message: MSG_FORBIDDEN) do |corrector|
-              # Remove the entire line including newline
               range = range_with_surrounding_space(magic_comment.source_range, side: :right, newlines: true)
               corrector.remove(range)
             end
           end
 
           def find_insert_position #: Integer
-            # Find the end of the first comment block (e.g., magic comments)
-            # and insert after it
             first_comment = processed_source.comments.first
-            # If the first comment doesn't exist or doesn't start at line 1, insert at the beginning
             return 0 unless first_comment&.source_range&.first_line == 1
 
             last_comment_in_block = find_last_comment_in_first_block
-            last_comment_in_block.source_range.end_pos + 1
+            # `end_pos` points at the newline terminating the comment, so `+ 1` moves past it.
+            # A file without a trailing newline has none, so clamp to the end of the buffer.
+            (last_comment_in_block.source_range.end_pos + 1).clamp(0, processed_source.buffer.source.length)
+          end
+
+          # The insert position lands at the end of the buffer when the file has no trailing
+          # newline. The magic comment then needs its own newline to stay on a separate line.
+          # @rbs insert_position: Integer
+          def insertion_text(insert_position) #: String
+            source = processed_source.buffer.source
+            return "# rbs_inline: enabled\n" if insert_position.zero? || source[insert_position - 1] == "\n"
+
+            "\n# rbs_inline: enabled\n"
           end
 
           def find_last_comment_in_first_block #: Parser::Source::Comment
@@ -127,13 +154,37 @@ module RuboCop
             comments[last_idx] || raise
           end
 
-          def style #: Symbol
-            cop_config["EnforcedStyle"]&.to_sym || :always
+          def effective_mode #: FileFilter::mode
+            mode = cop_config["Mode"]
+            if mode
+              # `raw.to_s.to_sym` handles YAML-native Integer / Boolean safely.
+              sym = mode.to_s.to_sym
+              return sym if FileFilter::SUPPORTED_MODES.include?(sym)
+
+              FileFilter.warn_invalid_mode(mode)
+            end
+
+            cop_config["EnforcedStyle"]&.to_sym == :never ? :opt_out : :opt_in
+          end
+
+          def allow_missing_comment? #: bool
+            cop_config["AllowMissingComment"] == true
+          end
+
+          def warn_deprecated_enforced_style #: void
+            return if self.class.enforced_style_deprecation_warned?
+            return if cop_config["EnforcedStyle"].nil?
+
+            self.class.mark_enforced_style_deprecation_warned!
+            Kernel.warn(
+              "[rubocop-rbs_inline] Style/RbsInline/RequireRbsInlineComment.EnforcedStyle is deprecated. " \
+              "Please migrate to `Style/RbsInline: Mode: opt_in` (was `EnforcedStyle: always`) or " \
+              "`Style/RbsInline: Mode: opt_out` (was `EnforcedStyle: never`). " \
+              "EnforcedStyle will be removed in the next major version."
+            )
           end
 
           def first_line_range #: Parser::Source::Range
-            # Find the first line of actual code (not comment-only lines)
-            # If there's no AST (e.g., file with only comments), use the first line
             first_line = processed_source.ast&.source_range&.first_line || 1
             processed_source.buffer.line_range(first_line)
           end

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

@@ -24,7 +24,9 @@ module RuboCop
         #   )
         #
         class StructClassCommentAlignment < Base
+          prepend FileFilter
           include ClassCommentAlignment
+          include StructClassMatcher
           extend AutoCorrector
 
           MSG = "Misaligned inline type annotation for Struct attribute."
@@ -35,22 +37,6 @@ module RuboCop
 
             check_comment_alignment(node)
           end
-
-          private
-
-          # @rbs node: RuboCop::AST::SendNode
-          def struct_like_class?(node) #: bool
-            return false unless node.method_name == :new
-
-            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Struct
-          end
-
-          # `Struct.new` treats a leading string argument as the struct name, so only
-          # symbol arguments are attributes.
-          # @rbs arg: RuboCop::AST::Node
-          def attr_argument?(arg) #: bool
-            arg.sym_type?
-          end
         end
       end
     end

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

@@ -25,6 +25,9 @@ module RuboCop
         #   end
         #
         class StructNewWithBlock < Base
+          prepend FileFilter
+          include StructClassMatcher
+
           MSG = "Do not use `Struct.new` 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."
@@ -38,15 +41,6 @@ module RuboCop
 
             add_offense(node)
           end
-
-          private
-
-          # @rbs node: RuboCop::AST::SendNode
-          def struct_like_class?(node) #: bool
-            return false unless node.method_name == :new
-
-            (r = node.receiver).is_a?(RuboCop::AST::ConstNode) && r.short_name == :Struct
-          end
         end
       end
     end

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

@@ -18,14 +18,18 @@ module RuboCop
         #   def method(arg); end
         #
         class UnmatchedAnnotations < Base
+          prepend FileFilter
           include CommentParser
           include RangeHelp
           include SourceCodeHelper
 
           MSG = "target parameter not found."
 
+          attr_reader :processed_comments #: Set[RBS::Inline::AnnotationParser::ParsingResult] -- matched to a def node
+
           def on_new_investigation #: void
             super
+            @processed_comments = Set.new
             parse_comments
           end
 
@@ -41,6 +45,8 @@ module RuboCop
 
           def on_investigation_end #: void
             parsed_comments.each do |comment|
+              next if processed?(comment)
+
               comment.each_annotation do |annotation|
                 case annotation
                 when RBS::Inline::AST::Annotations::BlockType,
@@ -57,15 +63,13 @@ module RuboCop
           private
 
           # @rbs node: RuboCop::AST::DefNode
-          def process(node) #: void # rubocop:disable Metrics/CyclomaticComplexity
+          def process(node) #: void
             arguments = arguments_for(node)
 
-            comment = parsed_comments.find do |r|
-              r.comments.map(&:location).map(&:start_line).include?(node.location.line - 1)
-            end
+            comment = leading_comment_for(node)
             return unless comment
 
-            parsed_comments.delete(comment)
+            mark_processed(comment)
             comment.each_annotation do |annotation|
               case annotation
               when RBS::Inline::AST::Annotations::IvarType
@@ -76,6 +80,25 @@ module RuboCop
             end
           end
 
+          # @rbs node: RuboCop::AST::DefNode
+          def leading_comment_for(node) #: RBS::Inline::AnnotationParser::ParsingResult?
+            parsed_comments.find do |comment|
+              next if processed?(comment)
+
+              comment.comments.map(&:location).map(&:start_line).include?(node.location.line - 1)
+            end
+          end
+
+          # @rbs comment: RBS::Inline::AnnotationParser::ParsingResult
+          def mark_processed(comment) #: void
+            processed_comments << comment
+          end
+
+          # @rbs comment: RBS::Inline::AnnotationParser::ParsingResult
+          def processed?(comment) #: bool
+            processed_comments.include?(comment)
+          end
+
           # @rbs node: RuboCop::AST::DefNode
           def arguments_for(node) #: Array[String] # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             args_for(node).children.flat_map do |argument| # rubocop:disable Metrics/BlockLength
@@ -104,7 +127,9 @@ module RuboCop
               when :forward_arg
                 ["..."]
               else
-                raise
+                # Unnamed parameters (ex. destructuring arguments; `def foo((a, b))`) are not
+                # annotatable because RBS::Inline does not generate types for them.
+                []
               end
             end
           end