docscribe 1.4.1 → 1.5.0

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

@@ -10,93 +10,319 @@ module Docscribe
       module TypeFormatter
         module_function
 
-        # Convert one RBS type object into a YARD-ish string.
+        # Dispatch an RBS type object to the appropriate YARD formatter.
         #
-        # Supported categories include:
-        # - base types (`bool`, `nil`, `void`, `untyped`)
-        # - optional and union types
-        # - named types with optional generic arguments
-        # - literal types
-        # - Proc types
-        #
-        # @note module_function: when included, also defines #to_yard (instance visibility: private)
-        # @param [Object] type RBS type object
-        # @param [Boolean] collapse_generics whether generic arguments should be omitted
+        # @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)
+        def to_yard(type, collapse_generics: false, collapse_object_generics: false)
           return 'Object' unless type
 
-          # RBS is loaded lazily by the provider; constants below exist only when rbs is available.
-          case type
-          when ::RBS::Types::Bases::Any
-            'Object'
-          when ::RBS::Types::Bases::Bool
-            'Boolean'
-          when ::RBS::Types::Bases::Void
-            'void'
-          when ::RBS::Types::Bases::Nil
-            'nil'
-          when ::RBS::Types::Optional
-            "#{to_yard(type.type, collapse_generics: collapse_generics)}?"
-          when ::RBS::Types::Union
-            format_union(type, collapse_generics: collapse_generics)
-          when ::RBS::Types::ClassInstance,
+          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
-            format_named(type, collapse_generics: collapse_generics)
-          when ::RBS::Types::Literal
-            literal_to_yard(type.literal)
-          when ::RBS::Types::Proc
-            'Proc'
-          else
-            fallback_string(type)
+          ].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: defines #to_yard_formatters (visibility: private)
+        # @return [Hash<Class, Docscribe::Types::RBS::TypeFormatter::formatter_fn>]
+        def 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 => 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::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
+
+        # Format RBS `any` type as the YARD-equivalent `Object`.
+        #
+        # @note module_function: defines #format_any (visibility: private)
+        # @return [String]
+        def format_any
+          'Object'
+        end
+
+        # Format RBS `bool` type as the YARD `Boolean`.
+        #
+        # @note module_function: defines #format_bool (visibility: private)
+        # @return [String]
+        def format_bool
+          'Boolean'
+        end
+
+        # Format RBS `void` type as the YARD `void`.
+        #
+        # @note module_function: defines #format_void (visibility: private)
+        # @return [String]
+        def format_void
+          'void'
+        end
+
+        # Format RBS `nil` type as the YARD `nil`.
+        #
+        # @note module_function: defines #format_nil (visibility: private)
+        # @return [String]
+        def format_nil
+          'nil'
+        end
+
+        # Format an RBS Optional type as a YARD optional type with `?` suffix.
+        #
+        # @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:, 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: defines #format_literal (visibility: private)
+        # @param [RBS::Types::Literal] lit a Ruby literal value
+        # @return [String]
+        def format_literal(lit)
+          case lit
+          when Integer then 'Integer'
+          when Float   then 'Float'
+          when String  then 'String'
+          when Symbol  then 'Symbol'
+          when TrueClass, FalseClass then 'Boolean'
+          when NilClass then 'nil'
+          else 'Object'
           end
         end
 
-        # Format an RBS union type as a comma-separated YARD union.
+        # Format RBS Proc type as the YARD `Proc`.
         #
-        # Example:
-        # - `String | Integer | nil` => `"String, Integer, nil"`
+        # @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: when included, also defines #format_union (instance visibility: private)
-        # @param [::RBS::Types::Union] type
-        # @param [Boolean] collapse_generics
+        # @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_union(type, collapse_generics:)
-          type.types.map { |t| to_yard(t, collapse_generics: collapse_generics) }
-              .uniq
-              .join(', ')
+        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 a named RBS type, optionally preserving generic arguments.
+        # Format RBS top type as YARD `Object`.
         #
-        # Examples:
-        # - `::String` => `"String"`
-        # - `::Hash[::Symbol, untyped]` => `"Hash<Symbol, Object>"`
-        # - with `collapse_generics: true` => `"Hash"`
+        # @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: when included, also defines #format_named (instance visibility: private)
-        # @param [Object] type named RBS type
-        # @param [Boolean] collapse_generics
+        # @note module_function: defines #format_bottom (visibility: private)
         # @return [String]
-        def format_named(type, collapse_generics:)
+        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: 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:, 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: 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:, collapse_object_generics:)
           name = type.name.to_s.delete_prefix('::')
-          args = type.respond_to?(:args) ? type.args : []
+          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
 
-        # Map a literal Ruby value from an RBS literal type into a YARD-ish type name.
+        # 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)
-        # @param [Object] lit literal value
+        # @note module_function: defines #literal_to_yard (visibility: private)
+        # @param [Object] lit a Ruby literal value
         # @return [String]
         def literal_to_yard(lit)
           case lit
@@ -109,23 +335,6 @@ module Docscribe
           else 'Object'
           end
         end
-
-        # Fallback string conversion for unsupported or unexpected RBS type objects.
-        #
-        # Performs a few normalizations for nicer YARD output:
-        # - strips leading `::`
-        # - converts `bool` to `Boolean`
-        # - converts `untyped` to `Object`
-        #
-        # @note module_function: when included, also defines #fallback_string (instance visibility: private)
-        # @param [Object] type
-        # @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,9 +15,10 @@ 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]
+        # @return [void]
         def initialize(collapse_generics: false)
           require 'rbs'
           @collapse_generics = !!collapse_generics
@@ -49,7 +50,9 @@ module Docscribe
         # @raise [::RBS::BaseError]
         # @raise [SyntaxError]
         # @raise [StandardError]
-        # @return [void]
+        # @return [void] if ::RBS::BaseError, SyntaxError, StandardError
+        # @return [nil] if LoadError
+        # @return [nil] if ::RBS::BaseError, SyntaxError, StandardError
         def load_from_string(source, label:)
           return unless defined?(RubyVM::AbstractSyntaxTree)
 
@@ -74,23 +77,32 @@ module Docscribe
             next unless decl.respond_to?(:members)
 
             container = normalize_container(decl.name.to_s)
+            decl.members.each { |member| process_method_member(container, member) }
+          end
+        end
 
-            decl.members.each do |member|
-              next unless method_definition_member?(member)
+        # Process a single method definition member into the index.
+        #
+        # @private
+        # @param [String] container normalized container name
+        # @param [Object] member RBS method definition member
+        # @return [void]
+        def process_method_member(container, member)
+          return unless method_definition_member?(member)
 
-              scope = member.kind == :singleton ? :class : :instance
-              overload = member.overloads&.first
-              next unless overload
+          scope = member.kind == :singleton ? :class : :instance
+          overload = member.overloads&.first
+          return unless overload
 
-              func = overload.method_type.type
-              @index[[container, scope, member.name.to_s.to_sym]] = build_signature(func)
-            end
-          end
+          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)
@@ -99,7 +111,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(
@@ -113,26 +125,38 @@ 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 = {}
+          param_types = {} #: Hash[String, String]
 
           add_positionals!(param_types, func.required_positionals)
           add_positionals!(param_types, func.optional_positionals)
           add_positionals!(param_types, func.trailing_positionals)
 
-          func.required_keywords.each { |kw, p| param_types[kw.to_s] = format_type(p.type) }
-          func.optional_keywords.each { |kw, p| param_types[kw.to_s] = format_type(p.type) }
+          add_keywords!(param_types, func.required_keywords)
+          add_keywords!(param_types, func.optional_keywords)
 
           param_types
         end
 
+        # Add keyword parameters to the normalized parameter map.
+        #
+        # @private
+        # @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|
+            param_types[kw.to_s] = format_type(p.type)
+          end
+        end
+
         # 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|
@@ -145,7 +169,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
@@ -163,7 +187,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
@@ -181,7 +205,7 @@ 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(
@@ -193,7 +217,7 @@ module Docscribe
         # 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('::')
@@ -202,7 +226,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/sorbet/rbi_provider.rb

@@ -12,11 +12,11 @@ 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]
+        # @return [void]
         def initialize(rbi_dirs:, collapse_generics: false)
           super(collapse_generics: collapse_generics)