yard-inline-rbs 0.1.0

data/lib/yard_inline_rbs/parameter_names.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # The parameter names of a method object, as YARD records them: 'x', '*rest', 'name:'.
+  class ParameterNames
+    # @rbs @object: YARD::CodeObjects::Base
+    # @rbs @raw: Array[String]?
+
+    # The key of a keyword rest without a name, in the keywords of `RbsFunctionTypes`.
+    KEYWORD_REST_KEY = '**' #: String
+
+    # The name of an unnamed parameter, e.g. of a method that only exists in a `.rbs` file.
+    # @rbs (Integer index) -> String
+    def self.placeholder(index)
+      "arg#{index}"
+    end
+
+    # @rbs (YARD::CodeObjects::Base object) -> void
+    def initialize(object)
+      @object = object
+    end
+
+    # @rbs () -> bool
+    def empty?
+      raw.empty?
+    end
+
+    # The positional names in Ruby order, without the '*' prefix.
+    # @rbs () -> Array[String]
+    def positional
+      raw.reject {|name| name.end_with?(':') || name.start_with?('**', '&')}
+         .map {|name| name.delete_prefix('*')}
+    end
+
+    # All names as @param tags spell them; YARD renders them in this order.
+    # @rbs () -> Array[String]
+    def tag_order
+      raw.map {|name| name.sub(/\A[*&]+/, '').delete_suffix(':')}
+    end
+
+    # Resolves the placeholder of an unnamed splat ('*') or keyword rest ('**') annotation.
+    #
+    # Returns `name` itself if it is no placeholder.
+    # @rbs (String name) -> String
+    def resolve_splat(name)
+      return name unless %w[* **].include?(name)
+
+      raw_name = raw.find do |param_name|
+        param_name.start_with?(name) && !param_name.start_with?("#{name}*")
+      end
+      actual_name = raw_name.to_s.delete_prefix(name)
+      actual_name.empty? ? name : actual_name
+    end
+
+    private
+
+    # @rbs () -> Array[String]
+    def raw
+      object = @object
+      return [] unless object.is_a?(YARD::CodeObjects::MethodObject)
+
+      @raw ||= object.parameters.map(&:first)
+    end
+  end
+end

data/lib/yard_inline_rbs/parse_result.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # What an annotation types, as the warnings name it and InlineTypes records it.
+  module Annotated
+    RETURN_TYPE = 'the return type' #: String
+    BLOCK = 'the block' #: String
+    SIGNATURE = 'the signature' #: String
+
+    # @rbs (String name) -> String
+    def self.parameter(name)
+      "parameter '#{name}'"
+    end
+  end
+
+  # The annotations of one method, attribute or constant, collected while parsing. The first
+  # annotation of a parameter, the return value or the block wins; a later one is recorded as a
+  # duplicate. An annotation whose type could not be parsed does not count.
+  class ParseResult
+    # @rbs @signature_added: bool
+
+    # The positional parameters, in Ruby order.
+    attr_reader :positional_param_types #: Array[PositionalParamType]
+    attr_reader :named_param_types #: Hash[String, NamedParamAnnotation]
+    attr_reader :return_type #: String?
+    attr_reader :return_description #: String?
+    attr_reader :block_annotation #: BlockAnnotation?
+    # The signatures of a method with overloads, which are no parameters of the method itself.
+    attr_reader :overloads #: Array[signature]
+    # The annotations that are not valid RBS.
+    attr_reader :parse_errors #: Array[String]
+    # The valid annotations the plugin does not use.
+    attr_reader :unsupported_annotations #: Array[String]
+    # What was annotated more than once, such as `parameter 'count'` or `the return type`.
+    attr_reader :duplicate_annotations #: Array[String]
+
+    # @rbs positional_param_types: Array[PositionalParamType]
+    # @rbs named_param_types: Hash[String, NamedParamAnnotation]
+    # @rbs return_type: String?
+    # @rbs return_description: String?
+    # @rbs block_annotation: BlockAnnotation?
+    # @rbs return: void
+    def initialize(positional_param_types: [], named_param_types: {}, return_type: nil,
+                   return_description: nil, block_annotation: nil)
+      @positional_param_types = positional_param_types
+      @named_param_types = named_param_types
+      @return_type = return_type
+      @return_description = return_description
+      @block_annotation = block_annotation
+      @overloads = [] #: Array[signature]
+      @parse_errors = []
+      @unsupported_annotations = []
+      @duplicate_annotations = []
+      @signature_added = false
+    end
+
+    # @return [Boolean] Whether there is no type to apply.
+    # @rbs () -> bool
+    def empty?
+      @positional_param_types.empty? && @named_param_types.empty? && @return_type.nil? &&
+        @block_annotation.nil? && @overloads.empty?
+    end
+
+    # @rbs (String? type, ?String? description) -> void
+    def add_return_type(type, description = nil)
+      return if type.nil?
+      return add_duplicate(Annotated::RETURN_TYPE) if @return_type
+
+      @return_type = type
+      @return_description = description
+    end
+
+    # @rbs (String name, NamedParamAnnotation annotation) -> void
+    def add_named_param(name, annotation)
+      return if annotation.type.nil?
+      return add_duplicate(Annotated.parameter(name)) if @named_param_types.key?(name)
+
+      @named_param_types[name] = annotation
+    end
+
+    # @rbs (BlockAnnotation? block_annotation) -> void
+    def add_block(block_annotation)
+      return if block_annotation.nil?
+      return add_duplicate(Annotated::BLOCK) if @block_annotation
+
+      @block_annotation = block_annotation
+    end
+
+    # Adds the signature of a method, or its overloads when it has several. Nothing for none.
+    # @rbs (Array[signature] signatures) -> void
+    def add_signatures(signatures)
+      return add_signature(signatures.first) if signatures.size < 2
+
+      add_overloads(signatures)
+    end
+
+    # Adds the signatures of a method with overloads, as TypeParser#method_signature returns them.
+    # Like a second signature, a second set of overloads is one duplicate.
+    # @rbs (Array[signature] signatures) -> void
+    def add_overloads(signatures)
+      return add_duplicate(Annotated::SIGNATURE) if @signature_added
+
+      @signature_added = true
+      @overloads.concat(signatures)
+    end
+
+    # Adds the parts of a method signature, as TypeParser#method_signature returns them, or
+    # nothing for nil, an invalid signature. A second signature is one duplicate, not one for each
+    # of its parts.
+    # @rbs (signature? signature) -> void
+    def add_signature(signature)
+      return if signature.nil?
+      return add_duplicate(Annotated::SIGNATURE) if @signature_added
+
+      @signature_added = true
+      @positional_param_types.concat(signature[:positional_types])
+      signature[:named_types].each {|name, annotation| add_named_param(name, annotation)}
+      add_return_type(signature[:return_type])
+      add_block(signature[:block_annotation])
+    end
+
+    # Records that `annotated`, an Annotated value, was typed again.
+    # @rbs (String annotated) -> void
+    def add_duplicate(annotated)
+      @duplicate_annotations << annotated
+    end
+  end
+
+  # The type and description of a positional parameter.
+  class PositionalParamType
+    attr_reader :type #: String?
+    attr_reader :name #: String?
+    attr_reader :description #: String?
+
+    # @rbs type: String?
+    # @rbs name: String?
+    # @rbs description: String?
+    # @rbs return: void
+    def initialize(type:, name: nil, description: nil)
+      @type = type
+      @name = name
+      @description = description
+    end
+  end
+
+  # The type and description of a keyword parameter, or of a splat. `rest` is true for a keyword
+  # rest (`**options`), which collects the other keywords.
+  class NamedParamAnnotation
+    attr_reader :type #: String?
+    attr_reader :description #: String?
+    attr_reader :rest #: bool
+
+    # @rbs type: String?
+    # @rbs description: String?
+    # @rbs rest: bool
+    # @rbs return: void
+    def initialize(type:, description: nil, rest: false)
+      @type = type
+      @description = description
+      @rest = rest
+    end
+  end
+
+  # The types a block yields and returns.
+  class BlockAnnotation
+    attr_reader :yield_types #: Array[String?]
+    attr_reader :return_type #: String?
+
+    # @rbs yield_types: Array[String?]
+    # @rbs return_type: String?
+    # @rbs return: void
+    def initialize(yield_types:, return_type:)
+      @yield_types = yield_types
+      @return_type = return_type
+    end
+  end
+end

data/lib/yard_inline_rbs/plugin.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+YARD::Tags::Library.define_tag('RBS annotation', :rbs)
+
+YARD::DocstringParser.after_parse do |parser|
+  YardInlineRbs::TagInjector.new(parser).inject
+end
+
+YardInlineRbs::RbsHandlerPatches.install
+
+# Also runs for YARD.parse_string. A callback that returns false would skip the file.
+YARD::Parser::SourceParser.before_parse_file do |_parser|
+  YardInlineRbs::AnnotationWarnings.clear_logged
+end
+
+YARD::Parser::SourceParser.before_parse_list do |files, _globals|
+  YardInlineRbs::DeclarationSource.clear_cache
+  YardInlineRbs::RbsFileTags.parse_rbs_first(files)
+end
+
+YARD::Parser::SourceParser.after_parse_list do |files, _globals|
+  YardInlineRbs::RbsFileTags.apply(files)
+  YardInlineRbs::DeclarationSource.clear_cache # Frees the lines of all files.
+end

data/lib/yard_inline_rbs/rbs_comment_parser.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # Collects the RBS annotations of `@rbs` tags, `#:` description lines and a trailing `#:`.
+  class RbsCommentParser
+    # @rbs @rbs_tag_texts: Array[String]
+    # @rbs @inline_annotations: Array[String]
+    # @rbs @source_line: String?
+    # @rbs @result: ParseResult
+    # @rbs @types: TypeParser
+
+    # @rbs rbs_tag_texts: Array[String] -- The texts of the `@rbs` tags, which YARD strips.
+    # @rbs inline_annotations: Array[String]
+    # @rbs source_line: String? -- The declaration line, for a trailing `#:`; nil to skip it.
+    # @rbs return: void
+    def initialize(rbs_tag_texts, inline_annotations, source_line)
+      @rbs_tag_texts = rbs_tag_texts
+      @inline_annotations = inline_annotations
+      @source_line = source_line
+    end
+
+    # @rbs () -> ParseResult
+    def parse
+      @result = ParseResult.new
+      @types = TypeParser.new(@result.parse_errors)
+      inline = InlineAnnotations.new(@types, @result)
+
+      @rbs_tag_texts.each {|text| process_rbs_tag(text)}
+      @inline_annotations.each {|line| inline.process_line(line)}
+      source_line = @source_line
+      inline.process_trailing(source_line) if source_line
+
+      @result
+    end
+
+    private
+
+    # A description after `--` would make a plain type, such as `[Integer, String] -- The pair.`,
+    # look like a method type, so only the type decides.
+    # @rbs (String text) -> void
+    def process_rbs_tag(text)
+      return if type_checker_only_annotation?(text)
+      return process_ivar_annotation(text) if text.start_with?('@')
+      return process_block_annotation(text) if text.start_with?('&')
+      return process_splat_annotation(text) if text.match?(/\A\*{1,2}\w*:/)
+      return record_unsupported(text) if structural_rbs_annotation?(text)
+
+      type_str, = RbsDescription.split(text)
+      return process_method_signature(text) if @types.method_type?(type_str)
+
+      process_named_or_standalone(text)
+    end
+
+    # @rbs (String text) -> void
+    def process_named_or_standalone(text)
+      if (match = text.match(/\A(\w+):(?!:)\s*(.+)/m))
+        process_named_annotation(match[1], match[2])
+      else
+        process_standalone_return_type(text)
+      end
+    end
+
+    # @rbs (String text) -> void
+    def record_unsupported(text)
+      @result.unsupported_annotations << text
+    end
+
+    # Annotations for the type checker only: `skip`, `...` and `module-self:`, and `override`,
+    # `generic`, `inherits` and `use` of the rbs-inline gem.
+    # @rbs (String text) -> bool
+    def type_checker_only_annotation?(text)
+      %w[skip ... override].include?(text) ||
+        text.start_with?('module-self:', 'generic ', 'inherits ', 'use ')
+    end
+
+    # An unnamed splat (`*: Type`) is recorded as '*' or '**'; TagInjector resolves the name.
+    # @rbs (String text) -> void
+    def process_splat_annotation(text)
+      match = text.match(/\A(\*{1,2})(\w*):\s*(.+)/m)
+      return @result.parse_errors << text unless match
+
+      stars = match[1].to_s
+      name = match[2].to_s
+      type_str, description = RbsDescription.split(match[3])
+      yard_type = @types.type(type_str)
+      @result.add_named_param(name.empty? ? stars : name,
+                              NamedParamAnnotation.new(type: yard_type, description: description))
+    end
+
+    # Declarations (def, class, end, attr_*) describe structure, not types.
+    # @rbs (String text) -> bool
+    def structural_rbs_annotation?(text)
+      text == 'end' ||
+        text.start_with?('def ', 'class ', 'attr_reader ', 'attr_writer ', 'attr_accessor ')
+    end
+
+    # The `?` of an optional block (`&block: ? () -> void`) is ignored.
+    # @rbs (String text) -> void
+    def process_block_annotation(text)
+      match = text.match(/\A&\w*:\s*(.+)/m)
+      return @result.parse_errors << text unless match
+
+      type_str, = RbsDescription.split(match[1])
+      @result.add_block(@types.block_annotation(type_str.delete_prefix('?')))
+    end
+
+    # @rbs (String text) -> void
+    def process_standalone_return_type(text)
+      type_str, = RbsDescription.split(text)
+      @result.add_return_type(@types.type(type_str))
+    end
+
+    # @rbs (String text) -> void
+    def process_ivar_annotation(text)
+      match = text.match(/\A@@?(\w+):\s*(.+)/m)
+      return unless match
+
+      type_str, = RbsDescription.split(match[2])
+      @types.type(type_str) # An invalid type is reported, although the annotation is not used.
+      @result.unsupported_annotations << text
+    end
+
+    # @rbs (String key, String value) -> void
+    def process_named_annotation(key, value)
+      type_str, description = RbsDescription.split(value)
+      yard_type = @types.type(type_str)
+
+      if key == 'return'
+        @result.add_return_type(yard_type, description)
+      else
+        @result.add_named_param(key, NamedParamAnnotation.new(type: yard_type,
+                                                              description: description))
+      end
+    end
+
+    # A signature with overloads that cannot all be parsed is documented with the ones that can.
+    # @rbs (String text) -> void
+    def process_method_signature(text)
+      overloads = RbsDescription.overloads(text)
+      @result.add_signatures(overloads.filter_map {|overload| @types.method_signature(overload)})
+    end
+  end
+end

data/lib/yard_inline_rbs/rbs_description.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # Splits an annotation value into its type and description: `Integer -- the count`.
+  # The type and the description may continue on the lines below, and the ` -- ` may also end a
+  # line or start one. A line starting with `| (` starts another overload of a method type.
+  class RbsDescription
+    # Before a description: ` -- `, or ` --` at the end of a line.
+    SEPARATOR = /\s--(?:\s|\z)/ #: Regexp
+
+    # A line that starts another overload, such as `| (Float) -> Float`. A union type can
+    # continue on a line starting with `| Float`, or `| [Float, String]`, so a line only starts an
+    # overload after a line with the arrow of a method type.
+    OVERLOAD = /\A\|\s*(?:[(\[{]|->)/ #: Regexp
+
+    # The type of every overload of a method type, without the bars and the descriptions. A type
+    # that is no overload, such as a union, is one.
+    # @rbs (String? text) -> Array[String]
+    def self.overloads(text)
+      groups(text).each_with_index.map do |group, index|
+        overload = group.join(' ')
+        overload = overload.delete_prefix('|') if index.positive?
+        overload.split(SEPARATOR).first.to_s.strip
+      end
+    end
+
+    # The type of the first overload, and the description, if any.
+    # @rbs (String? text) -> [String, String?]
+    def self.split(text)
+      type_string, description = groups(text).first.to_a.join(' ').split(SEPARATOR, 2)
+      description = description.to_s.strip
+      [type_string.to_s.strip, description.empty? ? nil : description]
+    end
+
+    # The lines of each overload: a line that starts another overload begins a new group.
+    # @rbs (String? text) -> Array[Array[String]]
+    def self.groups(text)
+      method_type = false
+      "#{text}\n".lines.map(&:strip).slice_before do |line|
+        starts_overload = method_type && line.match?(OVERLOAD)
+        method_type ||= line.include?('->')
+        starts_overload
+      end.to_a
+    end
+    private_class_method :groups
+  end
+end

data/lib/yard_inline_rbs/rbs_file_tags.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # Writes the types declared in `.rbs` files onto the YARD objects of the same methods,
+  # attributes and constants. This runs after all files are parsed, and only adds the tags that
+  # are missing, so docstrings and inline annotations win.
+  class RbsFileTags
+    # @rbs @path: String
+
+    # The YARD path separators of each kind of RBS member.
+    SEPARATORS = {
+      instance: %w[#], singleton: %w[.], singleton_instance: %w[# .]
+    }.freeze #: Hash[Symbol, Array[String]]
+
+    # Moves the `.rbs` files before the Ruby files, in place. YARD replaces the whole docstring
+    # of an object whenever it parses a comment later, so the Ruby docstrings, with their
+    # description and inline annotations, must be parsed last. YARD has no option for the order.
+    # @rbs (Array[String] files) -> void
+    def self.parse_rbs_first(files)
+      files.replace(files.partition {|file| file.end_with?('.rbs')}.flatten)
+    end
+
+    # @rbs (Array[String] files) -> void
+    def self.apply(files)
+      files.grep(/\.rbs\z/).each {|file| new(file).apply}
+    end
+
+    # @rbs (String path) -> void
+    def initialize(path)
+      @path = path
+    end
+
+    # @rbs () -> void
+    def apply
+      declarations.each {|declaration| apply_declaration(declaration, '')}
+    end
+
+    private
+
+    # A file that cannot be read or parsed is skipped with a warning, so it does not stop the
+    # documentation of the other files. Only this step is rescued, so a bug in the tagging is not.
+    # @rbs () -> Array[RBS::AST::Declarations::t]
+    def declarations
+      buffer = RBS::Buffer.new(name: Pathname(@path), content: File.read(@path))
+      RBS::Parser.parse_signature(buffer).last
+    rescue RBS::ParsingError, ArgumentError, SystemCallError => e
+      YardInlineRbs.warn("#{@path}: #{e.message}")
+      []
+    end
+
+    # @rbs (RBS::AST::Declarations::t | RBS::AST::Members::t declaration, String namespace)
+    #   -> void
+    def apply_declaration(declaration, namespace)
+      case declaration
+      when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+        apply_members(declaration.members, qualify(namespace, declaration.name))
+      when RBS::AST::Declarations::Constant
+        tag_object(qualify(namespace, declaration.name)) {|tags| tags.type(declaration.type)}
+      end
+    end
+
+    # @rbs (Array[RBS::AST::Members::t | RBS::AST::Declarations::t] members, String namespace)
+    #   -> void
+    def apply_members(members, namespace)
+      members.each do |member|
+        case member
+        when RBS::AST::Members::MethodDefinition then apply_method(member, namespace)
+        when RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter,
+             RBS::AST::Members::AttrAccessor then apply_attribute(member, namespace)
+        else apply_declaration(member, namespace)
+        end
+      end
+    end
+
+    # @rbs (RBS::AST::Members::MethodDefinition member, String namespace) -> void
+    def apply_method(member, namespace)
+      method_types = member.overloads.map(&:method_type)
+      tag_members(namespace, member.name.to_s, member.kind) {|tags| tags.method_types(method_types)}
+    end
+
+    # @rbs (RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter |
+    #   RBS::AST::Members::AttrAccessor member, String namespace) -> void
+    def apply_attribute(member, namespace)
+      attribute_names(member).each do |name|
+        tag_members(namespace, name, member.kind) {|tags| tags.type(member.type)}
+      end
+    end
+
+    # @rbs (RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter |
+    #   RBS::AST::Members::AttrAccessor member) -> Array[String]
+    def attribute_names(member)
+      name = member.name.to_s
+      case member
+      when RBS::AST::Members::AttrReader then [name]
+      when RBS::AST::Members::AttrWriter then ["#{name}="]
+      else [name, "#{name}="]
+      end
+    end
+
+    # @rbs (String namespace, String name, Symbol kind) { (MemberTags) -> void } -> void
+    def tag_members(namespace, name, kind, &)
+      SEPARATORS.fetch(kind).each {|separator| tag_object("#{namespace}#{separator}#{name}", &)}
+    end
+
+    # @rbs (String path) { (MemberTags) -> void } -> void
+    def tag_object(path)
+      object = YARD::Registry.at(path)
+      return if object.nil?
+
+      member_tags = MemberTags.new(object)
+      yield member_tags
+      # Only an inline annotation makes a duplicate, so its location is known.
+      AnnotationWarnings.new(InlineTypes.location(object).to_s)
+                        .report_rbs_file_duplicates(member_tags.duplicate_annotations, @path)
+    end
+
+    # @rbs (String namespace, RBS::TypeName name) -> String
+    def qualify(namespace, name)
+      return name.to_s.delete_prefix('::') if name.absolute?
+
+      [namespace, name.to_s].reject(&:empty?).join('::')
+    end
+  end
+end

data/lib/yard_inline_rbs/rbs_function_types.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # The parameter and return types of an RBS function type, e.g. `(Integer x) -> bool`, as YARD
+  # type strings.
+  class RbsFunctionTypes
+    # @rbs @function: RBS::Types::Function
+
+    # @rbs (RBS::Types::Function function) -> void
+    def initialize(function)
+      @function = function
+    end
+
+    # @rbs () -> Array[PositionalParamType]
+    def positional_types
+      positionals.map do |param|
+        PositionalParamType.new(type: RbsTypeFormatter.format(param.type),
+                                name: param.name&.to_s)
+      end
+    end
+
+    # An unnamed keyword rest is recorded under `ParameterNames::KEYWORD_REST_KEY`.
+    # @rbs () -> Hash[String, NamedParamAnnotation]
+    def named_types
+      rest = @function.rest_keywords
+      keywords.transform_values do |param|
+        NamedParamAnnotation.new(type: RbsTypeFormatter.format(param.type),
+                                 rest: param.equal?(rest))
+      end
+    end
+
+    # @rbs () -> Array[String]
+    def yield_types
+      positionals.map {|param| RbsTypeFormatter.format(param.type)}
+    end
+
+    # @rbs () -> String
+    def return_type
+      RbsTypeFormatter.format(@function.return_type)
+    end
+
+    private
+
+    # Ruby order: required, optional, rest, trailing.
+    # @rbs () -> Array[RBS::Types::Function::Param]
+    def positionals
+      @function.required_positionals + @function.optional_positionals +
+        [@function.rest_positionals].compact + @function.trailing_positionals
+    end
+
+    # @rbs () -> Hash[String, RBS::Types::Function::Param]
+    def keywords
+      result = @function.required_keywords.merge(@function.optional_keywords)
+                        .transform_keys(&:to_s)
+      rest = @function.rest_keywords
+      result[rest.name&.to_s || ParameterNames::KEYWORD_REST_KEY] = rest if rest
+      result
+    end
+  end
+end

data/lib/yard_inline_rbs/rbs_handler_patches.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module YardInlineRbs
+  # Changes to YARD's handlers for `.rbs` files. They write tags from the signature text: unnamed
+  # parameters get an empty name, generic types keep their RBS spelling, and the tags are lost
+  # when a Ruby docstring is parsed afterwards. RbsFileTags writes the tags once all files are
+  # parsed, so the method handler skips them, and the other handlers convert types with
+  # RbsTypeFormatter. There are two patches because the attribute and constant handlers write
+  # their tags inline, so only the type conversion can change them. Both rely on internals of
+  # YARD 0.9.45; the spec of `.install` fails when a YARD upgrade renames them.
+  module RbsHandlerPatches
+    # Applies both patches. The prepends live in a method, because YARD would read them as mixins
+    # of an unknown class when it documents this gem.
+    # @rbs () -> void
+    def self.install
+      YARD::Handlers::RBS::MethodHandler.prepend(MethodTags)
+      YARD::Handlers::RBS::MethodHandler.singleton_class.prepend(TypeConversion)
+    end
+
+    # Prepended to YARD::Handlers::RBS::MethodHandler.
+    module MethodTags
+      private
+
+      # @rbs (YARD::CodeObjects::MethodObject _object, Array[String]? _signatures) -> void
+      def apply_signature_tags(_object, _signatures); end
+    end
+
+    # Prepended to the singleton class of YARD::Handlers::RBS::MethodHandler.
+    module TypeConversion
+      # @rbs (String rbs) -> Array[String]
+      def rbs_type_to_yard_types(rbs)
+        rbs_type = RBS::Parser.parse_type(rbs, require_eof: true)
+        return super if rbs_type.nil?
+
+        [RbsTypeFormatter.format(rbs_type)]
+      rescue RBS::ParsingError
+        super
+      end
+    end
+  end
+end