docscribe 1.4.2 → 1.5.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

data/lib/docscribe/types/signature.rb

@@ -2,64 +2,44 @@
 
 module Docscribe
   module Types
-    # Simplified view of an RBS method signature for Docscribe.
-    #
-    # @!attribute return_type
-    #   @return [String] formatted return type for YARD output
-    # @!attribute param_types
-    #   @return [Hash{String=>String}] mapping of parameter name to formatted type
-    # @!attribute rest_positional
-    #   @return [RestPositional, nil] info for `*args`
-    # @!attribute rest_keywords
-    #   @return [RestKeywords, nil] info for `**kwargs`
-    #
     # @!attribute [rw] return_type
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [String]
+    #   @param [String] value
     #
     # @!attribute [rw] param_types
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [Hash<String, String>]
+    #   @param [Hash<String, String>] value
+    #
+    # @!attribute [rw] positional_types
+    #   @return [Array<String>]
+    #   @param [Array<String>] value
     #
     # @!attribute [rw] rest_positional
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [Docscribe::Types::RestPositional, nil]
+    #   @param [Docscribe::Types::RestPositional, nil] value
     #
     # @!attribute [rw] rest_keywords
-    #   @return [Object]
-    #   @param [Object] value
-    MethodSignature = Struct.new(:return_type, :param_types, :rest_positional, :rest_keywords, keyword_init: true)
+    #   @return [Docscribe::Types::RestKeywords, nil]
+    #   @param [Docscribe::Types::RestKeywords, nil] value
+    MethodSignature = Struct.new(:return_type, :param_types, :positional_types, :rest_positional, :rest_keywords,
+                                 keyword_init: true)
 
-    # Simplified representation of an RBS rest-positional parameter.
-    #
-    # @!attribute name
-    #   @return [String, nil] parameter name in RBS, if present
-    # @!attribute element_type
-    #   @return [String] formatted element type
-    #
     # @!attribute [rw] name
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [String, nil]
+    #   @param [String, nil] value
     #
     # @!attribute [rw] element_type
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [String]
+    #   @param [String] value
     RestPositional = Struct.new(:name, :element_type, keyword_init: true)
 
-    # Simplified representation of an RBS rest-keyword parameter.
-    #
-    # @!attribute name
-    #   @return [String, nil] parameter name in RBS, if present
-    # @!attribute type
-    #   @return [String] formatted kwargs type
-    #
     # @!attribute [rw] name
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [String, nil]
+    #   @param [String, nil] value
     #
     # @!attribute [rw] type
-    #   @return [Object]
-    #   @param [Object] value
+    #   @return [String]
+    #   @param [String] value
     RestKeywords = Struct.new(:name, :type, keyword_init: true)
   end
 end

data/lib/docscribe/types/sorbet/base_provider.rb

@@ -15,12 +15,15 @@ module Docscribe
       # - SourceProvider => inline `sig` declarations in the current Ruby file
       # - RBIProvider    => project RBI files
       class BaseProvider
+        # Initialize
+        #
         # @param [Boolean] collapse_generics whether generic container details
-        #   should be simplified during formatting
-        # @return [Object]
-        def initialize(collapse_generics: false)
+        # @param [Boolean] collapse_object_generics collapse Object generics
+        # @return [void]
+        def initialize(collapse_generics: false, collapse_object_generics: false)
           require 'rbs'
           @collapse_generics = !!collapse_generics
+          @collapse_object_generics = !!collapse_object_generics
           @index = {}
           @warned = false
         end
@@ -50,6 +53,8 @@ module Docscribe
         # @raise [SyntaxError]
         # @raise [StandardError]
         # @return [void]
+        # @return [nil] if LoadError
+        # @return [nil] if ::RBS::BaseError, SyntaxError, StandardError
         def load_from_string(source, label:)
           return unless defined?(RubyVM::AbstractSyntaxTree)
 
@@ -82,7 +87,7 @@ module Docscribe
         #
         # @private
         # @param [String] container normalized container name
-        # @param [Object] member
+        # @param [Object] member RBS method definition member
         # @return [void]
         def process_method_member(container, member)
           return unless method_definition_member?(member)
@@ -91,13 +96,15 @@ module Docscribe
           overload = member.overloads&.first
           return unless overload
 
-          func = overload.method_type.type
+          func = overload.method_type.type #: ::RBS::Types::Function
           @index[[container, scope, member.name.to_s.to_sym]] = build_signature(func)
         end
 
+        # Method definition member
+        #
         # @private
-        # @param [Object] member
-        # @return [Boolean]
+        # @param [Object] member member to check for method def
+        # @return [Boolean, nil]
         def method_definition_member?(member)
           defined?(::RBS::AST::Members::MethodDefinition) &&
             member.is_a?(::RBS::AST::Members::MethodDefinition)
@@ -106,7 +113,7 @@ module Docscribe
         # Convert an RBS function type into Docscribe's simplified signature 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)
           MethodSignature.new(
@@ -120,8 +127,8 @@ module Docscribe
         # Build a name => type map for ordinary positional/keyword parameters.
         #
         # @private
-        # @param [::RBS::Types::Function] func
-        # @return [Hash{String => String}]
+        # @param [RBS::Types::Function] func RBS function to extract params
+        # @return [Hash<String, String>]
         def build_param_types(func)
           param_types = {} #: Hash[String, String]
 
@@ -138,8 +145,8 @@ module Docscribe
         # 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|
@@ -150,8 +157,8 @@ module Docscribe
         # Add positional parameters with names to the normalized param map.
         #
         # @private
-        # @param [Hash{String => String}] param_types
-        # @param [Array<Object>] list
+        # @param [Hash<String, String>] param_types normalized param type map
+        # @param [Array<RBS::Types::Function::Param>] list positional parameter objects
         # @return [void]
         def add_positionals!(param_types, list)
           list.each do |p|
@@ -164,7 +171,7 @@ module Docscribe
         # 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
@@ -182,7 +189,7 @@ module Docscribe
         # YARD output, we expose that as a Hash keyed by Symbol.
         #
         # @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
@@ -200,28 +207,29 @@ 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
 
         # Normalize container names so lookups are consistent.
         #
         # @private
-        # @param [String] name
+        # @param [String] name method name
         # @return [String]
         def normalize_container(name)
-          name.to_s.delete_prefix('::')
+          name.to_s.delete_prefix('::').sub(/\[.*\]/, '').sub(/<.*>/, '')
         end
 
         # 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/sorbet/rbi_provider.rb

@@ -12,13 +12,14 @@ module Docscribe
       # any signatures that can be parsed are indexed into Docscribe's normalized
       # signature model.
       class RBIProvider < BaseProvider
+        # Initialize
+        #
         # @param [Array<String>] rbi_dirs directories scanned recursively for
-        #   `.rbi` files
         # @param [Boolean] collapse_generics whether generic container types
-        #   should be simplified during formatting
-        # @return [Object]
-        def initialize(rbi_dirs:, collapse_generics: false)
-          super(collapse_generics: collapse_generics)
+        # @param [Boolean] collapse_object_generics collapse Object generics
+        # @return [void]
+        def initialize(rbi_dirs:, collapse_generics: false, collapse_object_generics: false)
+          super(collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
 
           Array(rbi_dirs).each do |dir|
             path = Pathname(dir)

data/lib/docscribe/types/sorbet/source_provider.rb

@@ -10,13 +10,15 @@ module Docscribe
       # This provider parses the source being rewritten and indexes any leading
       # `sig` declarations it can resolve through the RBS RBI prototype bridge.
       class SourceProvider < BaseProvider
+        # Initialize
+        #
         # @param [String] source Ruby source containing inline `sig` declarations
         # @param [String] file source label used in diagnostics/debug warnings
         # @param [Boolean] collapse_generics whether generic container types
-        #   should be simplified during formatting
-        # @return [Object]
-        def initialize(source:, file:, collapse_generics: false)
-          super(collapse_generics: collapse_generics)
+        # @param [Boolean] collapse_object_generics collapse Object generics
+        # @return [void]
+        def initialize(source:, file:, collapse_generics: false, collapse_object_generics: false)
+          super(collapse_generics: collapse_generics, collapse_object_generics: collapse_object_generics)
           load_from_string(source, label: file)
         end
       end