docscribe 1.4.2 → 1.5.0

data/lib/docscribe/types/rbs/provider.rb

@@ -14,18 +14,19 @@ module Docscribe
       # The provider returns Docscribe's normalized signature model so the rest of
       # the pipeline can stay independent of the underlying signature source.
       class Provider
+        # Initialize
+        #
         # @param [Array<String>] sig_dirs directories containing `.rbs` files
         # @param [Array<String>] collection_dirs RBS collection directories
-        #   (loaded separately; on error they are silently dropped and only
-        #   user sig_dirs are used)
         # @param [Boolean] collapse_generics whether generic container types
-        #   should be simplified during formatting
-        # @return [Object]
-        def initialize(sig_dirs:, collection_dirs: [], collapse_generics: false)
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
+        # @return [void]
+        def initialize(sig_dirs:, collection_dirs: [], collapse_generics: false, collapse_object_generics: false)
           require 'rbs'
           @sig_dirs = Array(sig_dirs).map(&:to_s)
           @collection_dirs = Array(collection_dirs).map(&:to_s)
           @collapse_generics = !!collapse_generics
+          @collapse_object_generics = !!collapse_object_generics
           @env = nil
           @builder = nil
           @warned = false
@@ -41,7 +42,9 @@ module Docscribe
         # @param [Symbol, String] name method name
         # @raise [::RBS::BaseError]
         # @raise [StandardError]
-        # @return [Docscribe::Types::MethodSignature, nil]
+        # @return [Docscribe::Types::MethodSignature, nil] if StandardError
+        # @return [nil] if ::RBS::BaseError
+        # @return [nil] if StandardError
         def signature_for(container:, scope:, name:)
           load_env!
           lookup_signature(container, scope, name)
@@ -63,8 +66,6 @@ module Docscribe
         # dirs are dropped and only user sig_dirs are used.
         #
         # @private
-        # @raise [::RBS::BaseError]
-        # @raise [StandardError]
         # @return [void]
         def load_env!
           return if @env && @builder
@@ -84,13 +85,16 @@ module Docscribe
         # @return [Docscribe::Types::MethodSignature, nil]
         def lookup_signature(container, scope, name)
           definition = definition_for(container: container, scope: scope)
+          return nil unless definition
+
           method_def = definition.methods[name.to_sym]
           return nil unless method_def
 
           method_type = method_def.method_types.first
           return nil unless method_type
 
-          build_signature(method_type.type)
+          func = method_type.type #: ::RBS::Types::Function
+          build_signature(func)
         end
 
         # Try building an environment from combined dirs, falling back to
@@ -98,10 +102,11 @@ module Docscribe
         #
         # @private
         # @param [Array<String>] all_dirs combined sig and collection dirs
-        # @param [Array<String>] collection_dirs
+        # @param [Array<String>] collection_dirs RBS collection directories
         # @raise [::RBS::BaseError]
         # @raise [StandardError]
-        # @return [::RBS::Environment]
+        # @return [RBS::Environment] if ::RBS::BaseError
+        # @return [Object] if ::RBS::BaseError
         def try_with_fallback_build_env(all_dirs, collection_dirs)
           build_env(all_dirs)
         rescue ::RBS::BaseError => e
@@ -118,12 +123,12 @@ module Docscribe
         # Build an RBS environment from the given directories.
         #
         # @private
-        # @param [Array<String>] dirs
-        # @return [::RBS::Environment]
+        # @param [Array<String>] dirs directories to load RBS from
+        # @return [RBS::Environment]
         def build_env(dirs)
           loader = ::RBS::EnvironmentLoader.new
           # Load core types transitively
-          loader.add(library: 'rbs')
+          loader.add(library: 'rbs') # steep:ignore
 
           dirs.each do |dir|
             path = Pathname(dir)
@@ -138,9 +143,9 @@ module Docscribe
         # Build the appropriate instance or singleton definition for a container.
         #
         # @private
-        # @param [String] container
-        # @param [Symbol] scope
-        # @return [Object]
+        # @param [String] container fully qualified class/module name
+        # @param [Symbol] scope :instance or :class
+        # @return [RBS::Definition, nil]
         def definition_for(container:, scope:)
           type_name = parse_type_name(absolute_const(container))
           scope == :class ? @builder&.build_singleton(type_name) : @builder&.build_instance(type_name)
@@ -153,7 +158,7 @@ module Docscribe
         #
         # @private
         # @param [String] string e.g. "::Irb::Autosuggestions"
-        # @return [::RBS::TypeName]
+        # @return [RBS::TypeName]
         def parse_type_name(string)
           absolute = string.start_with?('::')
           *path, name = string.delete_prefix('::').split('::').map(&:to_sym)
@@ -167,7 +172,7 @@ module Docscribe
         # Normalize a container name into an absolute constant path.
         #
         # @private
-        # @param [String] container
+        # @param [String] container fully qualified class/module name
         # @return [String]
         def absolute_const(container)
           s = container.to_s
@@ -178,40 +183,49 @@ module Docscribe
         # model.
         #
         # @private
-        # @param [::RBS::Types::Function] func
+        # @param [RBS::Types::Function] func RBS function type to convert
         # @return [Docscribe::Types::MethodSignature]
         def build_signature(func)
+          param_types, positional_types = build_param_types(func)
           MethodSignature.new(
             return_type: format_type(func.return_type),
-            param_types: build_param_types(func),
+            param_types: param_types,
+            positional_types: positional_types,
             rest_positional: build_rest_positional(func),
             rest_keywords: build_rest_keywords(func)
           )
         end
 
-        # Build a name => type map for positional and keyword parameters.
+        # Build a name => type map and positional type list for all
+        # positional and keyword parameters.
+        #
+        # Returns [param_types (Hash), positional_types (Array)].
+        # positional_types includes ALL positional params in order (named
+        # and unnamed) so callers can fall back to positional matching when
+        # the RBS signature omits parameter names.
         #
         # @private
-        # @param [::RBS::Types::Function] func
-        # @return [Hash{String => String}]
+        # @param [RBS::Types::Function] func RBS function to extract params
+        # @return [(Hash<String, String>, Array<String>)]
         def build_param_types(func)
           param_types = {} #: Hash[String, String]
+          positional_types = [] #: Array[String]
 
-          add_positionals!(param_types, func.required_positionals)
-          add_positionals!(param_types, func.optional_positionals)
-          add_positionals!(param_types, func.trailing_positionals)
+          collect_positionals!(param_types, positional_types, func.required_positionals)
+          collect_positionals!(param_types, positional_types, func.optional_positionals)
+          collect_positionals!(param_types, positional_types, func.trailing_positionals)
 
           add_keywords!(param_types, func.required_keywords)
           add_keywords!(param_types, func.optional_keywords)
 
-          param_types
+          [param_types, positional_types]
         end
 
         # Add keyword parameters to the normalized parameter map.
         #
         # @private
-        # @param [Hash{String => String}] param_types
-        # @param [Hash{Symbol => Object}] keywords
+        # @param [Hash<String, String>] param_types normalized param type map
+        # @param [Hash<Symbol, RBS::Types::Function::Param>] keywords keyword parameter entries
         # @return [void]
         def add_keywords!(param_types, keywords)
           keywords.each do |kw, p|
@@ -219,24 +233,26 @@ module Docscribe
           end
         end
 
-        # Add named positional parameters to the normalized parameter map.
+        # Collect positional parameter types into both the name-keyed hash
+        # (when a name is available) and the ordered-position list (always).
         #
         # @private
-        # @param [Hash{String => String}] param_types
-        # @param [Array<Object>] list
+        # @param [Hash<String, String>] param_types normalized param type map
+        # @param [Array<String>] positional_types ordered type list
+        # @param [Array<RBS::Types::Function::Param>] list positional parameter objects
         # @return [void]
-        def add_positionals!(param_types, list)
+        def collect_positionals!(param_types, positional_types, list)
           list.each do |p|
-            next unless p.name
-
-            param_types[p.name.to_s] = format_type(p.type)
+            type_str = format_type(p.type)
+            positional_types << type_str
+            param_types[p.name.to_s] = type_str if p.name
           end
         end
 
         # Build normalized `*args` metadata.
         #
         # @private
-        # @param [::RBS::Types::Function] func
+        # @param [RBS::Types::Function] func RBS function for rest params
         # @return [Docscribe::Types::RestPositional, nil]
         def build_rest_positional(func)
           rp = func.rest_positionals
@@ -251,7 +267,7 @@ module Docscribe
         # Build normalized `**kwargs` metadata.
         #
         # @private
-        # @param [::RBS::Types::Function] func
+        # @param [RBS::Types::Function] func RBS function for rest keywords
         # @return [Docscribe::Types::RestKeywords, nil]
         def build_rest_keywords(func)
           rk = func.rest_keywords
@@ -267,21 +283,21 @@ module Docscribe
         # generated comments.
         #
         # @private
-        # @param [Object] type
+        # @param [Docscribe::Types::RBS::TypeFormatter::rbs_type] type RBS type object to format
         # @return [String]
         def format_type(type)
           Docscribe::Types::RBS::TypeFormatter.to_yard(
             type,
-            collapse_generics: @collapse_generics
+            collapse_generics: @collapse_generics,
+            collapse_object_generics: @collapse_object_generics
           )
         end
 
         # Emit a formatted RBS error warning with context-specific messaging.
         #
         # @private
-        # @param [StandardError] e the raised exception
+        # @param [RBS::BaseError, StandardError] error the raised exception
         # @param [String] context human-readable context label
-        # @param [StandardError] error the raised exception
         # @return [void]
         def handle_rbs_error(error, context)
           case error
@@ -298,7 +314,7 @@ module Docscribe
         # Print one debug warning per provider instance when debugging is enabled.
         #
         # @private
-        # @param [String] msg
+        # @param [String] msg warning message text
         # @return [void]
         def warn_once(msg)
           return unless ENV['DOCSCRIBE_RBS_DEBUG'] == '1'

data/lib/docscribe/types/rbs/type_formatter.rb

@@ -10,28 +10,107 @@ module Docscribe
       module TypeFormatter
         module_function
 
-        # rubocop:disable Metrics/AbcSize, Layout/LineLength
+        # Dispatch an RBS type object to the appropriate YARD formatter.
+        #
+        # @note module_function: defines #to_yard (visibility: private)
+        # @param [Docscribe::Types::RBS::TypeFormatter::rbs_type, nil] type the RBS type object to convert
+        # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics whether to collapse generics when all inner types are Object
+        # @return [String]
+        def to_yard(type, collapse_generics: false, collapse_object_generics: false)
+          return 'Object' unless type
+
+          handler = to_yard_formatters.find { |klass, _| type.is_a?(klass) }
+          return handler.last.call(type, cg: collapse_generics, cog: collapse_object_generics) if handler
+
+          if named_type?(type)
+            return format_named(type, # steep:ignore
+                                collapse_generics: collapse_generics,
+                                collapse_object_generics: collapse_object_generics)
+          end
+
+          fallback_string(type)
+        end
+
+        # Check if the given type object is a named RBS type (class, singleton, interface, or alias).
+        #
+        # @note module_function: defines #named_type? (visibility: private)
+        # @param [Docscribe::Types::RBS::TypeFormatter::rbs_type] type the RBS type object to check
+        # @return [Boolean]
+        def named_type?(type)
+          named_type_classes.any? { |klass| type.is_a?(klass) }
+        end
+
+        # Return or memoize the list of RBS type classes considered named types.
+        #
+        # @note module_function: defines #named_type_classes (visibility: private)
+        # @return [Array<Class>]
+        def named_type_classes
+          @named_type_classes ||= [
+            ::RBS::Types::ClassInstance,
+            ::RBS::Types::ClassSingleton,
+            ::RBS::Types::Interface,
+            ::RBS::Types::Alias
+          ].freeze
+        end
+
+        # Fallback conversion of an unrecognized RBS type to a cleaned string representation.
+        #
+        # @note module_function: defines #fallback_string (visibility: private)
+        # @param [Docscribe::Types::RBS::TypeFormatter::rbs_type] type the unrecognized RBS type object
+        # @return [String]
+        def fallback_string(type)
+          type.to_s
+              .gsub(/\A::/, '')
+              .gsub(/\bbool\b/, 'Boolean')
+              .gsub(/\buntyped\b/, 'Object')
+        end
+
         # Return or memoize the dispatch hash mapping RBS type classes to formatter lambdas.
         #
-        # @note module_function: when included, also defines #to_yard_formatters (instance visibility: private)
-        # @return [Hash{Class=>Proc}]
+        # @note module_function: defines #to_yard_formatters (visibility: private)
+        # @return [Hash<Class, Docscribe::Types::RBS::TypeFormatter::formatter_fn>]
         def to_yard_formatters
-          @to_yard_formatters ||= {
+          @to_yard_formatters ||= formatter_pairs.to_h.freeze
+        end
+
+        # Hash of RBS type classes and their YARD formatter lambdas.
+        #
+        # @note module_function: defines #formatter_pairs (visibility: private)
+        # @return [Hash<Class, Docscribe::Types::RBS::TypeFormatter::formatter_fn>]
+        def formatter_pairs # steep:ignore # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          @formatter_pairs ||= {
             ::RBS::Types::Bases::Any => ->(_, **) { format_any },
             ::RBS::Types::Bases::Bool => ->(_, **) { format_bool },
             ::RBS::Types::Bases::Void => ->(_, **) { format_void },
             ::RBS::Types::Bases::Nil => ->(_, **) { format_nil },
-            ::RBS::Types::Optional => ->(t, collapse_generics:) { format_optional(t, collapse_generics: collapse_generics) },
-            ::RBS::Types::Union => ->(t, collapse_generics:) { format_union(t, collapse_generics: collapse_generics) },
+            ::RBS::Types::Optional => lambda { |t, cg:, cog:|
+              format_optional(t, collapse_generics: cg, collapse_object_generics: cog)
+            },
+            ::RBS::Types::Union => lambda { |t, cg:, cog:|
+              format_union(t, collapse_generics: cg, collapse_object_generics: cog)
+            },
             ::RBS::Types::Literal => ->(t, **) { format_literal(t.literal) },
-            ::RBS::Types::Proc => ->(_, **) { format_proc }
+            ::RBS::Types::Proc => ->(_, **) { format_proc },
+            ::RBS::Types::Tuple => lambda { |t, cg:, cog:|
+              format_tuple(t, collapse_generics: cg, collapse_object_generics: cog)
+            },
+            ::RBS::Types::Bases::Top => ->(_, **) { format_top },
+            ::RBS::Types::Bases::Bottom => ->(_, **) { format_bottom },
+            ::RBS::Types::Bases::Self => ->(_, **) { format_self },
+            ::RBS::Types::Bases::Instance => ->(_, **) { format_instance },
+            ::RBS::Types::Bases::Class => ->(_, **) { format_class_type },
+            ::RBS::Types::Variable => ->(t, **) { format_variable(t) },
+            ::RBS::Types::Record => lambda { |t, cg:, cog:|
+              format_record(t, collapse_generics: cg, collapse_object_generics: cog)
+            },
+            ::RBS::Types::Intersection => ->(t, cg:, cog:) { format_intersection(t, collapse_generics: cg, collapse_object_generics: cog) }
           }.freeze
         end
-        # rubocop:enable Metrics/AbcSize, Layout/LineLength
 
         # Format RBS `any` type as the YARD-equivalent `Object`.
         #
-        # @note module_function: when included, also defines #format_any (instance visibility: private)
+        # @note module_function: defines #format_any (visibility: private)
         # @return [String]
         def format_any
           'Object'
@@ -39,7 +118,7 @@ module Docscribe
 
         # Format RBS `bool` type as the YARD `Boolean`.
         #
-        # @note module_function: when included, also defines #format_bool (instance visibility: private)
+        # @note module_function: defines #format_bool (visibility: private)
         # @return [String]
         def format_bool
           'Boolean'
@@ -47,7 +126,7 @@ module Docscribe
 
         # Format RBS `void` type as the YARD `void`.
         #
-        # @note module_function: when included, also defines #format_void (instance visibility: private)
+        # @note module_function: defines #format_void (visibility: private)
         # @return [String]
         def format_void
           'void'
@@ -55,7 +134,7 @@ module Docscribe
 
         # Format RBS `nil` type as the YARD `nil`.
         #
-        # @note module_function: when included, also defines #format_nil (instance visibility: private)
+        # @note module_function: defines #format_nil (visibility: private)
         # @return [String]
         def format_nil
           'nil'
@@ -63,18 +142,20 @@ module Docscribe
 
         # Format an RBS Optional type as a YARD optional type with `?` suffix.
         #
-        # @note module_function: when included, also defines #format_optional (instance visibility: private)
-        # @param [::RBS::Types::Optional] type the optional type to format
+        # @note module_function: defines #format_optional (visibility: private)
+        # @param [RBS::Types::Optional] type the optional type to format
         # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
         # @return [String]
-        def format_optional(type, collapse_generics:)
-          "#{to_yard(type.type, collapse_generics: collapse_generics)}?"
+        def format_optional(type, collapse_generics:, collapse_object_generics:)
+          "#{to_yard(type.type, collapse_generics: collapse_generics,
+                                collapse_object_generics: collapse_object_generics)}?"
         end
 
         # Map a Ruby literal value to its corresponding YARD type name.
         #
-        # @note module_function: when included, also defines #format_literal (instance visibility: private)
-        # @param [Object] lit a Ruby literal value
+        # @note module_function: defines #format_literal (visibility: private)
+        # @param [RBS::Types::Literal] lit a Ruby literal value
         # @return [String]
         def format_literal(lit)
           case lit
@@ -90,46 +171,157 @@ module Docscribe
 
         # Format RBS Proc type as the YARD `Proc`.
         #
-        # @note module_function: when included, also defines #format_proc (instance visibility: private)
+        # @note module_function: defines #format_proc (visibility: private)
         # @return [String]
         def format_proc
           'Proc'
         end
 
+        # Format an RBS Tuple type as a parenthesized list of YARD types.
+        #
+        # @note module_function: defines #format_tuple (visibility: private)
+        # @param [RBS::Types::Tuple] type the tuple type to format
+        # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
+        # @return [String]
+        def format_tuple(type, collapse_generics:, collapse_object_generics:)
+          "(#{type.types.map do |t|
+            to_yard(t, collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
+          end.join(', ')})"
+        end
+
+        # Format RBS top type as YARD `Object`.
+        #
+        # @note module_function: defines #format_top (visibility: private)
+        # @return [String]
+        def format_top
+          'Object'
+        end
+
+        # Format RBS bottom type as YARD `Object`.
+        #
+        # @note module_function: defines #format_bottom (visibility: private)
+        # @return [String]
+        def format_bottom
+          'Object'
+        end
+
+        # Format RBS self type as YARD `self`.
+        #
+        # @note module_function: defines #format_self (visibility: private)
+        # @return [String]
+        def format_self
+          'self'
+        end
+
+        # Format RBS instance type as YARD `Object`.
+        #
+        # @note module_function: defines #format_instance (visibility: private)
+        # @return [String]
+        def format_instance
+          'Object'
+        end
+
+        # Format RBS class type as YARD `Class`.
+        #
+        # @note module_function: defines #format_class_type (visibility: private)
+        # @return [String]
+        def format_class_type
+          'Class'
+        end
+
+        # Format an RBS type variable as its name string.
+        #
+        # @note module_function: defines #format_variable (visibility: private)
+        # @param [RBS::Types::Variable] type the variable type
+        # @return [String]
+        def format_variable(type)
+          type.name.to_s
+        end
+
+        # Format an RBS Record type as a YARD `Hash<Symbol, ValueType>`.
+        #
+        # @note module_function: defines #format_record (visibility: private)
+        # @param [RBS::Types::Record] type the record type
+        # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
+        # @return [String]
+        def format_record(type, collapse_generics:, collapse_object_generics:)
+          value_types = type.all_fields.values.map do |(ty, _)|
+            to_yard(ty, collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
+          end.uniq
+          "Hash<Symbol, #{value_types.join(', ')}>"
+        end
+
+        # Format an RBS Intersection type as `Type & Type` list.
+        #
+        # @note module_function: defines #format_intersection (visibility: private)
+        # @param [RBS::Types::Intersection] type the intersection type
+        # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
+        # @return [String]
+        def format_intersection(type, collapse_generics:, collapse_object_generics:)
+          type.types.map do |t|
+            to_yard(t, collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
+          end.join(' & ')
+        end
+
         # Format an RBS Union type as a comma-separated list of YARD types.
         #
-        # @note module_function: when included, also defines #format_union (instance visibility: private)
-        # @param [::RBS::Types::Union] type the union type to format
+        # @note module_function: defines #format_union (visibility: private)
+        # @param [RBS::Types::Union] type the union type to format
         # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics collapse Object generics flag
         # @return [String]
-        def format_union(type, collapse_generics:)
-          type.types.map { |t| to_yard(t, collapse_generics: collapse_generics) }
-              .uniq
-              .join(', ')
+        def format_union(type, collapse_generics:, collapse_object_generics:)
+          type.types.map do |t|
+            to_yard(t, collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
+          end
+                    .uniq
+                    .join(', ')
         end
 
         # Format an RBS named type (class, interface, alias) with optional generic arguments.
         #
-        # @note module_function: when included, also defines #format_named (instance visibility: private)
-        # @param [::RBS::Types::ClassInstance, ::RBS::Types::Interface, ::RBS::Types::Alias] type
+        # @note module_function: defines #format_named (visibility: private)
+        # @param [Docscribe::Types::RBS::TypeFormatter::named_rbs_type] type the unrecognized RBS type object
         # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics whether to collapse generics when all inner types are Object
         # @return [String]
-        def format_named(type, collapse_generics:)
+        def format_named(type, collapse_generics:, collapse_object_generics:)
           name = type.name.to_s.delete_prefix('::')
           args = type.respond_to?(:args) ? type.args : [] #: Array[untyped]
 
           if args && !args.empty?
-            return name if collapse_generics
-
-            "#{name}<#{args.map { |a| to_yard(a, collapse_generics: collapse_generics) }.join(', ')}>"
+            format_generic_args(name, args, collapse_generics: collapse_generics,
+                                            collapse_object_generics: collapse_object_generics)
           else
             name
           end
         end
 
+        # Format generic type arguments for a named type.
+        #
+        # @note module_function: defines #format_generic_args (visibility: private)
+        # @param [String] name the type name
+        # @param [Array<Docscribe::Types::RBS::TypeFormatter::rbs_type>] args the generic type arguments
+        # @param [Boolean] collapse_generics whether to omit generic type arguments
+        # @param [Boolean] collapse_object_generics whether to collapse generics when all inner types are Object
+        # @return [String]
+        def format_generic_args(name, args, collapse_generics:, collapse_object_generics:)
+          return name if collapse_generics
+
+          formatted = args.map do |a|
+            to_yard(a, collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
+          end
+          return name if collapse_object_generics && formatted.all? { |s| s == 'Object' }
+
+          "#{name}<#{formatted.join(', ')}>"
+        end
+
         # Convert a Ruby literal value to its YARD type name string.
         #
-        # @note module_function: when included, also defines #literal_to_yard (instance visibility: private)
+        # @note module_function: defines #literal_to_yard (visibility: private)
         # @param [Object] lit a Ruby literal value
         # @return [String]
         def literal_to_yard(lit)
@@ -143,57 +335,6 @@ module Docscribe
           else 'Object'
           end
         end
-
-        # Dispatch an RBS type object to the appropriate YARD formatter.
-        #
-        # @note module_function: when included, also defines #to_yard (instance visibility: private)
-        # @param [::RBS::Type] type the RBS type object to convert
-        # @param [Boolean] collapse_generics whether to omit generic type arguments
-        # @return [String]
-        def to_yard(type, collapse_generics: false)
-          return 'Object' unless type
-
-          handler = to_yard_formatters.find { |klass, _| type.is_a?(klass) }
-          return handler.last.call(type, collapse_generics: collapse_generics) if handler
-
-          return format_named(type, collapse_generics: collapse_generics) if named_type?(type)
-
-          fallback_string(type)
-        end
-
-        # Check if the given type object is a named RBS type (class, singleton, interface, or alias).
-        #
-        # @note module_function: when included, also defines #named_type? (instance visibility: private)
-        # @param [::RBS::Type] type the RBS type object to check
-        # @return [Boolean]
-        def named_type?(type)
-          named_type_classes.any? { |klass| type.is_a?(klass) }
-        end
-
-        # Return or memoize the list of RBS type classes considered named types.
-        #
-        # @note module_function: when included, also defines #named_type_classes (instance visibility: private)
-        # @return [Array<Class>]
-        def named_type_classes
-          @named_type_classes ||= [
-            ::RBS::Types::ClassInstance,
-            ::RBS::Types::ClassSingleton,
-            ::RBS::Types::Interface,
-            ::RBS::Types::Alias
-          ].freeze
-        end
-
-        # Fallback conversion of an unrecognized RBS type to a cleaned string representation.
-        #
-        # @note module_function: when included, also defines #fallback_string (instance visibility: private)
-        # @param [::RBS::Type] type the unrecognized RBS type object
-        # @return [String]
-        def fallback_string(type)
-          type.to_s
-              .gsub(/\A::/, '')
-              .gsub(/\bbool\b/, 'Boolean')
-              .gsub(/\buntyped\b/, 'Object')
-        end
       end
     end
   end