sord 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc4c58d9ccea9406b38e20c3d6d92357a962e49aa91884b421a496d9302566d2
-  data.tar.gz: cdcc1158ce99895796423ba6b833f68e261e09d6a61b6892104d5948a3c64625
+  metadata.gz: 12567f3b935a14271aedb28b62acfcfef3cb1e3bfb80fd294732947490dfb765
+  data.tar.gz: c40c2790500508fd2e575ab01e471cf7fe0e90f0c6d255285c7474433b65952c
 SHA512:
-  metadata.gz: 984cf951dc9a0ee9ea6180402e60817c866d171f313c102a34f4d8d20cc36ca95d11c24082b46810b70eb35fa6e67643bd4b9e3007889ec7a87f25fa0db3c44d
-  data.tar.gz: b9f25ab1affc00c9c2a25b90db7735c1ee8c89e53cd98ef1a04087b58d9efe2f8878e54f6a1cbdc913c38142507aaff74a9e437151cd74fd5f7b612cbab4f38f
+  metadata.gz: 85435a86928840302557121d0deeafde94a0b70905da93403c642a303ec773f5f4503b316beed31709052839a597e671df9ac554410d4c169843e859aebf361d
+  data.tar.gz: 77795ca64b509b9c7e7da210fac12d2b27bb8fe9e952ab61dc1d87c92189a1d0e457a4546bce2cebac4230a643f96072559c39bd477fc7e345819c98dd0b3bdd

data/.github/workflows/ruby.yml

@@ -6,10 +6,10 @@ jobs:
   test:
     strategy:
       matrix:
-        ruby: [2.4, 2.5, 2.6, 2.7, 3.0]
+        ruby: [2.7, 3.0, 3.1]
     continue-on-error: false
-      
-    runs-on: ubuntu-latest    
+
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby

data/CHANGELOG.md

@@ -3,6 +3,31 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [5.0.0] - 2022-10-06
+### Added
+- If a derived class does not provide tags for a method, but it is overridden from a base class
+  which does, then the base class' documentation will be used to generate types for the derived
+  method.
+- When generating RBS, if a duck type matches one of RBS' built-in interfaces, this type will be
+  generated instead. (For example, `#to_s` will generate the type `_ToS`.)
+- Added the `--hide-private` flag, which will omit outputting items with private visibility.
+- To improve resolution, types for gems are now loaded from the RBS collection.
+- If you are using custom YARD tags, Sord can now be made aware of these by passing the `--tags`
+  option.
+
+### Changed
+- **Breaking change**: Support for versions of Ruby prior to 2.7 has been dropped.
+- When Sord runs YARD automatically, it no longer generates HTML documentation, since this isn't
+  necessary for Sord's analysis. If you were relying on this as part of your workflow, then this
+  could be a **breaking change**.
+
+### Fixed
+- Duck-typed methods ending with `?` or `!`, and operator methods like `#[]=`, are now correctly
+  recognised as duck types.
+- Fixed an exception when referring to built-in types with root namespace (`::Array<Foo>`) syntax.
+- `@yieldparams` without a parameter name no longer cause an exception, and instead use default
+  names of the pattern: `arg0`, `arg1`, ...
+
 ## [4.0.0] - 2022-07-19
 ### Added
 - Constants are now assigned types when generating RBS, using `@return`.

data/README.md

@@ -85,6 +85,8 @@ Sord also takes some flags to alter the generated file:
     (You cannot specify both `--include-messages` and `--exclude-messages`.)
   - `--exclude-untyped`: Exclude methods and attributes with untyped return
     values.
+  - `--tags TAGS`: Provide a list of comma-separated tags as understood by the
+    `yard` command. E.g. `--tags 'mytag:My Description,mytag2:My New Description'
 
 ## Example
 

data/exe/sord

@@ -22,8 +22,10 @@ command :gen do |c|
   c.option '--include-messages STRING', String, 'Whitelists a comma-separated string of log message types'
   c.option '--keep-original-comments', 'Retains original YARD comments rather than converting them to Markdown'
   c.option '--skip-constants', 'Excludes constants from generated file'
+  c.option '--hide-private', 'Exclude any object marked with @!visibility private'
   c.option '--use-original-initialize-return', 'Uses the specified return type for #initialize rather than void'
   c.option '--exclude-untyped', 'Exclude methods and attributes with untyped return values'
+  c.option '--tags TAGS', Array, 'Tag parameters for the YARD command'
 
   c.action do |args, options|
     options.default(
@@ -34,12 +36,14 @@ command :gen do |c|
       break_params: 4,
       replace_errors_with_untyped: false,
       replace_unresolved_with_untyped: false,
+      hide_private: false,
       exclude_messages: nil,
       include_messages: nil,
       keep_original_comments: false,
       skip_constants: false,
       use_original_initialize_return: false,
       exclude_untyped: false,
+      tags: [],
     )
 
     if args.length != 1
@@ -86,7 +90,7 @@ command :gen do |c|
 
     plugin.parlour = klass.new(break_params: plugin_options[:break_params])
     plugin.generate(plugin.parlour.root)
-    
+
     File.write(args.first, plugin.parlour.send(generator_method))
   end
 end

data/lib/sord/generator.rb

@@ -28,6 +28,7 @@ module Sord
     # @option options [Integer] break_params
     # @option options [Boolean] replace_errors_with_untyped
     # @option options [Boolean] replace_unresolved_with_untyped
+    # @option options [Boolean] hide_private
     # @option options [Boolean] comments
     # @option options [Parlour::Generator] generator
     # @option options [Parlour::TypedObject] root
@@ -53,18 +54,25 @@ module Sord
       @replace_errors_with_untyped = options[:replace_errors_with_untyped]
       @replace_unresolved_with_untyped = options[:replace_unresolved_with_untyped]
       @keep_original_comments = options[:keep_original_comments]
+      @hide_private = options[:hide_private]
       @skip_constants = options[:skip_constants]
       @use_original_initialize_return = options[:use_original_initialize_return]
       @exclude_untyped = options[:exclude_untyped]
 
+      @type_converter_config = TypeConverter::Configuration.new(
+        output_language: @mode,
+        replace_errors_with_untyped: @replace_errors_with_untyped,
+        replace_unresolved_with_untyped: @replace_unresolved_with_untyped,
+      )
+
       # Hook the logger so that messages are added as comments
       Logging.add_hook do |type, msg, item, **opts|
         # Hack: the "exclude untyped" log message needs to print somewhere, but
         # if there's no future object for that comment to associate with, it'll
         # never be printed!
-        # Instead, add an arbitrary containing the comment 
+        # Instead, add an arbitrary containing the comment
         if opts[:immediate]
-          @current_object.create_arbitrary(code: "# sord #{type} - #{msg}") 
+          @current_object.create_arbitrary(code: "# sord #{type} - #{msg}")
         else
           @current_object.add_comment_to_next_child("sord #{type} - #{msg}")
         end
@@ -120,6 +128,7 @@ module Sord
       inserted_constant_names = Set.new
 
       item.constants(included: false).each do |constant|
+        next if @hide_private && constant.visibility == :private
         # Take a constant (like "A::B::CONSTANT"), split it on each '::', and
         # set the constant name to the last string in the array.
         constant_name = constant.to_s.split('::').last
@@ -144,8 +153,7 @@ module Sord
             TypeConverter.yard_to_parlour(
               return_tags.map(&:types).flatten,
               constant,
-              @replace_errors_with_untyped,
-              @replace_unresolved_with_untyped
+              @type_converter_config,
             )
           end
           @current_object.create_constant(constant_name, type: returns) do |c|
@@ -246,12 +254,33 @@ module Sord
       end
     end
 
+    # @param method [YARD::CodeObjects::MethodObject]
+    # @param tag_name [String]
+    # @return [Array<YARD::Tags::Tag>]
+    def method_tags(method, tag_name)
+      tags = method.tags(tag_name)
+      return tags if tags.any? || method.overridden_method.nil?
+
+      method.overridden_method.tags(tag_name)
+    end
+
+    # @param method [YARD::CodeObjects::MethodObject]
+    # @param tag_name [String]
+    # @return [YARD::Tags::Tag, nil]
+    def method_tag(method, tag_name)
+      tag = method.tag(tag_name)
+      return tag if tag || method.overridden_method.nil?
+
+      method.overridden_method.tag(tag_name)
+    end
+
     # Given a YARD NamespaceObject, add lines defining its methods and their
     # signatures to the current file.
     # @param [YARD::CodeObjects::NamespaceObject] item
     # @return [void]
     def add_methods(item)
       item.meths(inherited: false).each do |meth|
+        next if @hide_private && meth.visibility == :private
         count_method
 
         # If the method is an alias, skip it so we don't define it as a
@@ -267,17 +296,18 @@ module Sord
 
         # Sort parameters
         meth.parameters.reverse.sort! { |pair1, pair2| sort_params(pair1, pair2) }
+
         # This is better than iterating over YARD's "@param" tags directly
         # because it includes parameters without documentation
         # (The gsubs allow for better splat-argument compatibility)
         parameter_names_and_defaults_to_tags = meth.parameters.map do |name, default|
-          [[name, fix_default_if_unary_minus(default)], meth.tags('param')
+          [[name, fix_default_if_unary_minus(default)], method_tags(meth, 'param')
             .find { |p| p.name&.gsub('*', '')&.gsub(':', '') == name.gsub('*', '').gsub(':', '') }]
         end.to_h
 
         # Add block param if there is no named param but YARD tags are present
         if !parameter_names_and_defaults_to_tags.any? { |((name, _), _)| name.start_with? '&' } \
-            && (meth.tags('yieldparam').any? || meth.tag('yieldreturn'))
+            && (method_tags(meth, 'yieldparam').any? || method_tag(meth, 'yieldreturn'))
           parameter_names_and_defaults_to_tags[['&blk']] = nil
         end
 
@@ -285,22 +315,22 @@ module Sord
           name = name_and_default.first
 
           if tag
-            TypeConverter.yard_to_parlour(tag.types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+            TypeConverter.yard_to_parlour(tag.types, meth, @type_converter_config)
           elsif name.start_with? '&'
             # Find yieldparams and yieldreturn
-            yieldparams = meth.tags('yieldparam')
-            yieldreturn = meth.tag('yieldreturn')&.types
+            yieldparams = method_tags(meth, 'yieldparam')
+            yieldreturn = method_tag(meth, 'yieldreturn')&.types
             yieldreturn = nil if yieldreturn&.length == 1 &&
               yieldreturn&.first&.downcase == 'void'
 
             # Create strings
-            params = yieldparams.map do |param|
+            params = yieldparams.map.with_index do |param, i|
               Parlour::Types::Proc::Parameter.new(
-                param.name.gsub('*', ''),
-                TypeConverter.yard_to_parlour(param.types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+                param.name&.gsub('*', '') || "arg#{i}",
+                TypeConverter.yard_to_parlour(param.types, meth, @type_converter_config)
               )
             end
-            returns = TypeConverter.yard_to_parlour(yieldreturn, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+            returns = TypeConverter.yard_to_parlour(yieldreturn, meth, @type_converter_config)
 
             # Create proc types, if possible
             if yieldparams.empty? && yieldreturn.nil?
@@ -315,24 +345,24 @@ module Sord
 
             unless getter
               if parameter_names_and_defaults_to_tags.length == 1 \
-                && meth.tags('param').length == 1 \
-                && meth.tag('param').types
+                && method_tags(meth, 'param').length == 1 \
+                && method_tag(meth, 'param').types
 
                 Logging.infer("argument name in single @param inferred as #{parameter_names_and_defaults_to_tags.first.first.first.inspect}", meth)
-                next TypeConverter.yard_to_parlour(meth.tag('param').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+                next TypeConverter.yard_to_parlour(method_tag(meth, 'param').types, meth, @type_converter_config)
               else
                 Logging.omit("no YARD type given for #{name.inspect}, using untyped", meth)
                 next Parlour::Types::Untyped.new
               end
             end
 
-            return_types = getter.tags('return').flat_map(&:types)
+            return_types = method_tags(getter, 'return').flat_map(&:types)
             unless return_types.any?
               Logging.omit("no YARD type given for #{name.inspect}, using untyped", meth)
               next Parlour::Types::Untyped.new
             end
             inferred_type = TypeConverter.yard_to_parlour(
-              return_types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+              return_types, meth, @type_converter_config)
 
             Logging.infer("inferred type of parameter #{name.inspect} as #{inferred_type.describe} using getter's return type", meth)
             inferred_type
@@ -340,11 +370,11 @@ module Sord
             # Is this the only argument, and was a @param specified without an
             # argument name? If so, infer it
             if parameter_names_and_defaults_to_tags.length == 1 \
-              && meth.tags('param').length == 1 \
-              && meth.tag('param').types
+              && method_tags(meth, 'param').length == 1 \
+              && method_tag(meth, 'param').types
 
               Logging.infer("argument name in single @param inferred as #{parameter_names_and_defaults_to_tags.first.first.first.inspect}", meth)
-              TypeConverter.yard_to_parlour(meth.tag('param').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+              TypeConverter.yard_to_parlour(method_tag(meth, 'param').types, meth, @type_converter_config)
             else
               Logging.omit("no YARD type given for #{name.inspect}, using untyped", meth)
               Parlour::Types::Untyped.new
@@ -352,7 +382,7 @@ module Sord
           end
         end
 
-        return_tags = meth.tags('return')
+        return_tags = method_tags(meth, 'return')
         returns = if meth.name == :initialize && !@use_original_initialize_return
           nil
         elsif return_tags.length == 0
@@ -361,7 +391,7 @@ module Sord
         elsif return_tags.length == 1 && %w{void nil}.include?(return_tags&.first&.types&.first&.downcase)
           nil
         else
-          TypeConverter.yard_to_parlour(meth.tag('return').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+          TypeConverter.yard_to_parlour(method_tag(meth, 'return').types, meth, @type_converter_config)
         end
 
         rbs_block = nil
@@ -447,10 +477,12 @@ module Sord
           # Get all given types
           yard_types = []
           if reader
+            next if @hide_private && reader.visibility == :private
             yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +
               reader.tags('param').flat_map(&:types)
           end
           if writer
+            next if @hide_private && writer.visibility == :private
             yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +
               writer.tags('param').flat_map(&:types)
           end
@@ -465,7 +497,7 @@ module Sord
             parlour_type = Parlour::Types::Untyped.new
           else
             parlour_type = TypeConverter.yard_to_parlour(
-              yard_types, reader || writer, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
+              yard_types, reader || writer, @type_converter_config)
           end
 
           # Generate attribute
@@ -538,6 +570,7 @@ module Sord
     # @param [YARD::CodeObjects::NamespaceObject] item
     # @return [void]
     def add_namespace(item)
+      return if @hide_private && item.visibility == :private
       count_namespace
 
       superclass = nil

data/lib/sord/parlour_plugin.rb

@@ -1,5 +1,6 @@
 # typed: true
 require 'parlour'
+require 'yard/tags/library'
 
 module Sord
   class ParlourPlugin < Parlour::Plugin
@@ -42,17 +43,21 @@ module Sord
         Sord::Logging.error('No output format given; please specify --rbi or --rbs')
         exit 1
       end
-  
+
       if (options[:rbi] && options[:rbs])
         Sord::Logging.error('You cannot specify both --rbi and --rbs; please use only one')
         exit 1
       end
-  
+
       if options[:regenerate]
         begin
           Sord::Logging.info('Running YARD...')
           Sord::ParlourPlugin.with_clean_env do
-            system('bundle exec yard')
+            tag_param = ''
+            options[:tags]&.each do |tag|
+              tag_param += "--tag #{tag} "
+            end
+            system("bundle exec yard #{tag_param} --no-output")
           end
         rescue Errno::ENOENT
           Sord::Logging.error('The YARD tool could not be found on your PATH.')
@@ -63,15 +68,26 @@ module Sord
       end
 
       options[:mode] = \
-        if options[:rbi] then :rbi elsif options[:rbs] then :rbs end 
+        if options[:rbi] then :rbi elsif options[:rbs] then :rbs end
       options[:parlour] = @parlour
       options[:root] = root
 
+      add_custom_tags
+
       Sord::Generator.new(options).run
 
       true
     end
 
+    def add_custom_tags
+      return if options[:tags].empty?
+
+      options[:tags].each do |tag|
+        name, description = tag.split(':')
+        YARD::Tags::Library.define_tag(description, name)
+      end
+    end
+
     def self.with_clean_env &block
       meth = if Bundler.respond_to?(:with_unbundled_env)
                :with_unbundled_env
@@ -81,4 +97,4 @@ module Sord
       Bundler.send meth, &block
     end
   end
-end
+end

data/lib/sord/resolver.rb

@@ -1,23 +1,80 @@
 # typed: false
 require 'stringio'
+require 'rbs'
+require 'rbs/cli'
 
 module Sord
   module Resolver
     # @return [void]
     def self.prepare
+      return @names_to_paths if @names_to_paths
+
+      gem_objects = {}
+      load_gem_objects(gem_objects)
+
       # Construct a hash of class names to full paths
-      @@names_to_paths ||= YARD::Registry.all(:class)
+      @names_to_paths = YARD::Registry.all(:class)
         .group_by(&:name)
-        .map { |k, v| [k.to_s, v.map(&:path)] }
+        .map { |k, v| [k.to_s, v.map(&:path).to_set] }
         .to_h
-        .merge(builtin_classes.map { |x| [x, [x]] }.to_h) do |k, a, b|
-          a | b
+        .merge(builtin_classes.map { |x| [x, Set.new([x])] }.to_h) { |_k, a, b| a.union(b) }
+        .merge(gem_objects) { |_k, a, b| a.union(b) }
+    end
+
+    def self.load_gem_objects(hash)
+      all_decls = []
+      begin
+        RBS::CLI::LibraryOptions.new.loader.load(env: all_decls)
+      rescue RBS::Collection::Config::CollectionNotAvailable
+        Sord::Logging.warn("Could not load RBS collection - run rbs collection install for dependencies")
+      end
+      add_rbs_objects_to_paths(all_decls, hash)
+
+      gem_paths = Bundler.load.specs.map(&:full_gem_path)
+      gem_paths.each do |path|
+        if File.exists?("#{path}/rbi")
+          Dir["#{path}/rbi/**/*.rbi"].each do |sigfile|
+            tree = Parlour::TypeLoader.load_file(sigfile)
+            add_rbi_objects_to_paths(tree.children, hash)
+          end
         end
+      end
+    end
+
+    def self.add_rbs_objects_to_paths(all_decls, names_to_paths, path=[])
+      klasses = [
+        RBS::AST::Declarations::Module,
+        RBS::AST::Declarations::Class,
+        RBS::AST::Declarations::Constant
+      ]
+      all_decls.each do |decl|
+        next unless klasses.include?(decl.class)
+        name = decl.name.to_s
+        new_path = path + [name]
+        names_to_paths[name] ||= Set.new
+        names_to_paths[name] << new_path.join('::')
+        add_rbs_objects_to_paths(decl.members, names_to_paths, new_path) if decl.respond_to?(:members)
+      end
+    end
+
+    def self.add_rbi_objects_to_paths(nodes, names_to_paths, path=[])
+      klasses = [
+        Parlour::RbiGenerator::Constant,
+        Parlour::RbiGenerator::ModuleNamespace,
+        Parlour::RbiGenerator::ClassNamespace
+      ]
+      nodes.each do |node|
+        next unless klasses.include?(node.class)
+        new_path = path + [node.name]
+        names_to_paths[node.name] ||= Set.new
+        names_to_paths[node.name] << new_path.join('::')
+        add_rbi_objects_to_paths(node.children, names_to_paths, new_path) if node.respond_to?(:children)
+      end
     end
 
     # @return [void]
     def self.clear
-      @@names_to_paths = nil
+      @names_to_paths = nil
     end
 
     # @param [String] name
@@ -28,7 +85,7 @@ module Sord
       # If the name starts with ::, then we've been given an explicit path from root - just use that
       return [name] if name.start_with?('::')
 
-      (@@names_to_paths[name.split('::').last] || [])
+      (@names_to_paths[name.split('::').last] || [])
         .select { |x| x.end_with?(name) }
     end
 
@@ -43,9 +100,9 @@ module Sord
       # This prints some deprecation warnings, so suppress them
       prev_stderr = $stderr
       $stderr = StringIO.new
-      
+
       major = RUBY_VERSION.split('.').first.to_i
-      sorted_set_removed = major >= 3 
+      sorted_set_removed = major >= 3
 
       Object.constants
         .reject { |x| sorted_set_removed && x == :SortedSet }

data/lib/sord/type_converter.rb

@@ -21,10 +21,15 @@ module Sord
     GENERIC_TYPE_REGEX =
       /(#{SIMPLE_TYPE_REGEX})\s*[<{]\s*(.*)\s*[>}]/
 
+    # Matches valid method names.
+    # From: https://stackoverflow.com/a/4379197/2626000
+    METHOD_NAME_REGEX =
+      /(?:[a-z_]\w*[?!=]?|\[\]=?|<<|>>|\*\*|[!~+\*\/%&^|-]|[<>]=?|<=>|={2,3}|![=~]|=~)/i 
+
     # Match duck types which require the object implement one or more methods,
     # like '#foo', '#foo & #bar', '#foo&#bar&#baz', and '#foo&#bar&#baz&#foo_bar'.
     DUCK_TYPE_REGEX =
-      /^\#[a-zA-Z_][\w]*(?:[a-zA-Z_][\w=]*)*(?:( ?\& ?\#)*[a-zA-Z_][\w=]*)*$/
+      /^\##{METHOD_NAME_REGEX}(?:\s*\&\s*\##{METHOD_NAME_REGEX})*$/
 
     # A regular expression which matches ordered lists in the format of
     # either "Array(String, Symbol)" or "(String, Symbol)".
@@ -90,17 +95,35 @@ module Sord
       result
     end
 
+    # Configuration for how the type converter should work in particular cases.
+    class Configuration
+      def initialize(replace_errors_with_untyped:, replace_unresolved_with_untyped:, output_language:)
+        @output_language = output_language
+        @replace_errors_with_untyped = replace_errors_with_untyped
+        @replace_unresolved_with_untyped = replace_unresolved_with_untyped
+      end
+
+      # The language which the generated types will be converted to - one of
+      # `:rbi` or `:rbs`.
+      attr_accessor :output_language
+
+      # @return [Boolean] If true, T.untyped is used instead of SORD_ERROR_
+      #   constants for unknown types.
+      attr_accessor :replace_errors_with_untyped
+
+      # @param [Boolean] replace_unresolved_with_untyped If true, T.untyped is
+      #   used when Sord is unable to resolve a constant.
+      attr_accessor :replace_unresolved_with_untyped
+    end
+
     # Converts a YARD type into a Parlour type.
     # @param [Boolean, Array, String] yard The YARD type.
     # @param [YARD::CodeObjects::Base] item The CodeObject which the YARD type
     #   is associated with. This is used for logging and can be nil, but this
     #   will lead to less informative log messages.
-    # @param [Boolean] replace_errors_with_untyped If true, T.untyped is used
-    #   instead of SORD_ERROR_ constants for unknown types.
-    # @param [Boolean] replace_unresolved_with_untyped If true, T.untyped is used
-    #   when Sord is unable to resolve a constant.
+    # @param [Configuration] config The generation configuration.
     # @return [Parlour::Types::Type]
-    def self.yard_to_parlour(yard, item = nil, replace_errors_with_untyped = false, replace_unresolved_with_untyped = false)
+    def self.yard_to_parlour(yard, item, config)
       case yard
       when nil # Type not specified
         Parlour::Types::Untyped.new
@@ -113,7 +136,7 @@ module Sord
         # selection of any of the types
         types = yard
           .reject { |x| x == 'nil' }
-          .map { |x| yard_to_parlour(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
+          .map { |x| yard_to_parlour(x, item, config) }
           .uniq(&:hash)
         result = types.length == 1 \
           ? types.first
@@ -142,7 +165,7 @@ module Sord
               unless yard == new_path
             Parlour::Types::Raw.new(new_path)
           else
-            if replace_unresolved_with_untyped
+            if config.replace_unresolved_with_untyped
               Logging.warn("#{yard} wasn't able to be resolved to a constant in this project, replaced with untyped", item)
               Parlour::Types::Untyped.new
             else
@@ -154,33 +177,43 @@ module Sord
           Parlour::Types::Raw.new(yard)
         end
       when DUCK_TYPE_REGEX
-        Logging.duck("#{yard} looks like a duck type, replacing with untyped", item)
-        Parlour::Types::Untyped.new
+        if config.output_language == :rbs && (type = duck_type_to_rbs_type(yard))
+          Logging.duck("#{yard} looks like a duck type with an equivalent RBS interface, replacing with #{type.generate_rbs}", item)
+          type
+        else
+          Logging.duck("#{yard} looks like a duck type, replacing with untyped", item)
+          Parlour::Types::Untyped.new
+        end
       when /^#{GENERIC_TYPE_REGEX}$/
         generic_type = $1
         type_parameters = $2
 
+        # If we don't do this, `const_defined?` will resolve "::Array" as the actual Ruby `Array`
+        # type, not `Parlour::Types::Array`!
+        relative_generic_type = generic_type.start_with?('::') \
+          ? generic_type[2..-1] : generic_type
+
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_parlour(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
-        if SINGLE_ARG_GENERIC_TYPES.include?(generic_type) && parameters.length > 1
-          Parlour::Types.const_get(generic_type).new(Parlour::Types::Union.new(parameters))
-        elsif generic_type == 'Class' && parameters.length == 1
+          .map { |x| yard_to_parlour(x, item, config) }
+        if SINGLE_ARG_GENERIC_TYPES.include?(relative_generic_type) && parameters.length > 1
+          Parlour::Types.const_get(relative_generic_type).new(Parlour::Types::Union.new(parameters))
+        elsif relative_generic_type == 'Class' && parameters.length == 1
           Parlour::Types::Class.new(parameters.first)
-        elsif generic_type == 'Hash'
+        elsif relative_generic_type == 'Hash'
           if parameters.length == 2
             Parlour::Types::Hash.new(*parameters)
           else
-            handle_sord_error(parameters.map(&:describe).join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, replace_errors_with_untyped)
+            handle_sord_error(parameters.map(&:describe).join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, config.replace_errors_with_untyped)
           end
         else
-          if Parlour::Types.const_defined?(generic_type)
+          if Parlour::Types.constants.include?(relative_generic_type.to_sym)
             # This generic is built in to parlour, but sord doesn't
             # explicitly know about it.
-            Parlour::Types.const_get(generic_type).new(*parameters)
+            Parlour::Types.const_get(relative_generic_type).new(*parameters)
           else
             # This is a user defined generic
             Parlour::Types::Generic.new(
-              yard_to_parlour(generic_type),
+              yard_to_parlour(generic_type, nil, config),
               parameters
             )
           end
@@ -190,22 +223,22 @@ module Sord
       when ORDERED_LIST_REGEX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_parlour(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
+          .map { |x| yard_to_parlour(x, item, config) }
         Parlour::Types::Tuple.new(parameters)
       when SHORTHAND_HASH_SYNTAX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_parlour(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
+          .map { |x| yard_to_parlour(x, item, config) }
         # Return a warning about an invalid hash when it has more or less than two elements.
         if parameters.length == 2
           Parlour::Types::Hash.new(*parameters)
         else
-          handle_sord_error(parameters.map(&:describe).join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, replace_errors_with_untyped)
+          handle_sord_error(parameters.map(&:describe).join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, config.replace_errors_with_untyped)
         end
       when SHORTHAND_ARRAY_SYNTAX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_parlour(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
+          .map { |x| yard_to_parlour(x, item, config) }
         parameters.one? \
           ? Parlour::Types::Array.new(parameters.first)
           : Parlour::Types::Array.new(Parlour::Types::Union.new(parameters))
@@ -215,7 +248,7 @@ module Sord
         return Parlour::Types::Raw.new(from_yaml.class.to_s) \
           if [Symbol, Float, Integer].include?(from_yaml.class)
 
-        return handle_sord_error(yard.to_s, "#{yard.inspect} does not appear to be a type", item, replace_errors_with_untyped)
+        return handle_sord_error(yard.to_s, "#{yard.inspect} does not appear to be a type", item, config.replace_errors_with_untyped)
       end
     end
 
@@ -233,5 +266,50 @@ module Sord
         ? Parlour::Types::Untyped.new
         : Parlour::Types::Raw.new("SORD_ERROR_#{name.gsub(/[^0-9A-Za-z_]/i, '')}")
     end
+
+    # Taken from: https://github.com/ruby/rbs/blob/master/core/builtin.rbs
+    # When the latest commit was: 6c847d1
+    #
+    # Interfaces which use generic arguments have those arguments as `untyped`, since I'm not aware
+    # of any standard way that these are specified.
+    DUCK_TYPES_TO_RBS_TYPE_NAMES = {
+      # Concrete
+      "#to_i" => "_ToI",
+      "#to_int" => "_ToInt",
+      "#to_r" => "_ToR",
+      "#to_s" => "_ToS",
+      "#to_str" => "_ToStr",
+      "#to_proc" => "_ToProc",
+      "#to_path" => "_ToPath",
+      "#read" => "_Reader",
+      "#readpartial" => "_ReaderPartial",
+      "#write" => "_Writer",
+      "#rewind" => "_Rewindable",
+      "#to_io" => "_ToIO",
+      "#exception" => "_Exception",
+
+      # Generic - these will be put in a `Types::Raw`, so writing RBS syntax is a little devious,
+      # but by their nature we know they'll only be used in an RBS file, so it's probably fine
+      "#to_hash" => "_ToHash[untyped, untyped]",
+      "#each" => "_Each[untyped]",
+    }
+
+    # Given a YARD duck type string, attempts to convert it to one of a list of pre-defined RBS
+    # built-in interfaces.
+    #
+    # For example, the common duck type `#to_s` has a built-in RBS equivalent `_ToS`.
+    #
+    # If no such interface exists, returns `nil`.
+    #
+    # @param [String] type
+    # @return [Parlour::Types::Type, nil]
+    def self.duck_type_to_rbs_type(type)
+      type_name = DUCK_TYPES_TO_RBS_TYPE_NAMES[type]
+      if !type_name.nil?
+        Parlour::Types::Raw.new(type_name)
+      else
+        nil
+      end
+    end
   end
 end

data/lib/sord/version.rb

@@ -1,4 +1,4 @@
 # typed: strong
 module Sord
-  VERSION = '4.0.0'
+  VERSION = '5.0.0'
 end

data/rbi/sord.rbi

@@ -1,7 +1,7 @@
 # typed: strong
-
+# typed: strong
 module Sord
-  VERSION = T.let('3.0.1', T.untyped)
+  VERSION = T.let('5.0.0', T.untyped)
 
   # Handles writing logs to stdout and any other classes which request them.
   module Logging
@@ -42,6 +42,7 @@ module Sord
     def self.valid_types?(value); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # A generic log message writer which is called by all other specific logging
     # methods. This shouldn't be called outside of the Logging class itself.
     # 
@@ -57,32 +58,36 @@ module Sord
         kind: Symbol,
         header: String,
         msg: String,
-        item: YARD::CodeObjects::Base
+        item: YARD::CodeObjects::Base,
+        opts: T.untyped
       ).void
     end
-    def self.generic(kind, header, msg, item); end
+    def self.generic(kind, header, msg, item, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print a warning message. This should be used for things which require the
     # user's attention but do not prevent the process from stopping.
     # 
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.warn(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.warn(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print an info message. This should be used for generic informational
     # messages which the user doesn't need to act on.
     # 
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.info(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.info(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print a duck-typing message. This should be used when the YARD 
     # documentation contains duck typing, which isn't supported by Sorbet, so
     # it is substituted for something different.
@@ -90,20 +95,22 @@ module Sord
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.duck(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.duck(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print an error message. This should be used for things which require the
     # current process to stop.
     # 
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.error(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.error(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print an infer message. This should be used when the user should be told
     # that some information has been filled in or guessed for them, and that 
     # information is likely correct.
@@ -111,10 +118,11 @@ module Sord
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.infer(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.infer(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print an omit message. This should be used as a special type of warning
     # to alert the user that there is some information missing, but this
     # information is not critical to the completion of the process.
@@ -122,20 +130,22 @@ module Sord
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.omit(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.omit(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Print a done message. This should be used when a process completes
     # successfully.
     # 
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
-    def self.done(msg, item = nil); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base), opts: T.untyped).void }
+    def self.done(msg, item = nil, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    # sord omit - no YARD type given for "**opts", using untyped
     # Invokes all registered hooks on the logger.
     # 
     # _@param_ `kind` — The kind of log message this is.
@@ -143,8 +153,15 @@ module Sord
     # _@param_ `msg` — The log message to write.
     # 
     # _@param_ `item` — The CodeObject which this log  is associated with, if any. This is shown before the log message if it is specified.
-    sig { params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base).void }
-    def self.invoke_hooks(kind, msg, item); end
+    sig do
+      params(
+        kind: Symbol,
+        msg: String,
+        item: YARD::CodeObjects::Base,
+        opts: T.untyped
+      ).void
+    end
+    def self.invoke_hooks(kind, msg, item, **opts); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
     # Adds a hook to the logger.
@@ -156,6 +173,25 @@ module Sord
     sig { void }
     def self.prepare; end
 
+    # sord omit - no YARD type given for "hash", using untyped
+    # sord omit - no YARD return type given, using untyped
+    sig { params(hash: T.untyped).returns(T.untyped) }
+    def self.load_gem_objects(hash); end
+
+    # sord omit - no YARD type given for "all_decls", using untyped
+    # sord omit - no YARD type given for "names_to_paths", using untyped
+    # sord omit - no YARD type given for "path", using untyped
+    # sord omit - no YARD return type given, using untyped
+    sig { params(all_decls: T.untyped, names_to_paths: T.untyped, path: T.untyped).returns(T.untyped) }
+    def self.add_rbs_objects_to_paths(all_decls, names_to_paths, path = []); end
+
+    # sord omit - no YARD type given for "nodes", using untyped
+    # sord omit - no YARD type given for "names_to_paths", using untyped
+    # sord omit - no YARD type given for "path", using untyped
+    # sord omit - no YARD return type given, using untyped
+    sig { params(nodes: T.untyped, names_to_paths: T.untyped, path: T.untyped).returns(T.untyped) }
+    def self.add_rbi_objects_to_paths(nodes, names_to_paths, path = []); end
+
     sig { void }
     def self.clear; end
 
@@ -182,7 +218,7 @@ module Sord
   class Generator
     VALID_MODES = T.let([:rbi, :rbs], T.untyped)
 
-    # _@return_ — The number of objects this generator has processed so 
+    # _@return_ — The number of objects this generator has processed so
     # far.
     sig { returns(Integer) }
     def object_count; end
@@ -217,7 +253,6 @@ module Sord
     def add_constants(item); end
 
     # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
-    # sord warn - Parlour::TypedObject wasn't able to be resolved to a constant in this project
     # Adds comments to an object based on a docstring.
     # 
     # _@param_ `item`
@@ -226,6 +261,22 @@ module Sord
     sig { params(item: YARD::CodeObjects::NamespaceObject, typed_object: Parlour::TypedObject).void }
     def add_comments(item, typed_object); end
 
+    # sord warn - YARD::CodeObjects::MethodObject wasn't able to be resolved to a constant in this project
+    # sord warn - YARD::Tags::Tag wasn't able to be resolved to a constant in this project
+    # _@param_ `method`
+    # 
+    # _@param_ `tag_name`
+    sig { params(method: YARD::CodeObjects::MethodObject, tag_name: String).returns(T::Array[YARD::Tags::Tag]) }
+    def method_tags(method, tag_name); end
+
+    # sord warn - YARD::CodeObjects::MethodObject wasn't able to be resolved to a constant in this project
+    # sord warn - YARD::Tags::Tag wasn't able to be resolved to a constant in this project
+    # _@param_ `method`
+    # 
+    # _@param_ `tag_name`
+    sig { params(method: YARD::CodeObjects::MethodObject, tag_name: String).returns(T.nilable(YARD::Tags::Tag)) }
+    def method_tag(method, tag_name); end
+
     # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
     # Given a YARD NamespaceObject, add lines defining its methods and their
     # signatures to the current file.
@@ -250,7 +301,7 @@ module Sord
     sig { params(item: YARD::CodeObjects::NamespaceObject).void }
     def add_namespace(item); end
 
-    # Populates the generator with the contents of the YARD registry. You 
+    # Populates the generator with the contents of the YARD registry. You
     # must load the YARD registry first!
     sig { void }
     def populate; end
@@ -279,8 +330,15 @@ module Sord
     sig { params(pair1: T::Array[T.untyped], pair2: T::Array[T.untyped]).returns(T.untyped) }
     def sort_params(pair1, pair2); end
 
+    # Removes the last character of a default parameter value if it begins with
+    # '-', working around a bug in YARD. (See lsegal/yard #894)
+    # 
+    # _@param_ `default`
+    sig { params(default: String).returns(T.nilable(String)) }
+    def fix_default_if_unary_minus(default); end
+
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    # _@return_ — The 
+    # _@return_ — The
     # errors encountered by by the generator. Each element is of the form
     # [message, item, line].
     sig { returns(T::Array[[String, YARD::CodeObjects::Base, Integer]]) }
@@ -297,6 +355,10 @@ module Sord
     sig { params(root: T.untyped).returns(T.untyped) }
     def generate(root); end
 
+    # sord omit - no YARD return type given, using untyped
+    sig { returns(T.untyped) }
+    def add_custom_tags; end
+
     # sord omit - no YARD return type given, using untyped
     sig { params(block: T.untyped).returns(T.untyped) }
     def self.with_clean_env(&block); end
@@ -315,11 +377,33 @@ module Sord
   module TypeConverter
     SIMPLE_TYPE_REGEX = T.let(/(?:\:\:)?[a-zA-Z_][\w]*(?:\:\:[a-zA-Z_][\w]*)*/, T.untyped)
     GENERIC_TYPE_REGEX = T.let(/(#{SIMPLE_TYPE_REGEX})\s*[<{]\s*(.*)\s*[>}]/, T.untyped)
-    DUCK_TYPE_REGEX = T.let(/^\#[a-zA-Z_][\w]*(?:[a-zA-Z_][\w=]*)*(?:( ?\& ?\#)*[a-zA-Z_][\w=]*)*$/, T.untyped)
+    METHOD_NAME_REGEX = T.let(/(?:[a-z_]\w*[?!=]?|\[\]=?|<<|>>|\*\*|[!~+\*\/%&^|-]|[<>]=?|<=>|={2,3}|![=~]|=~)/i, T.untyped)
+    DUCK_TYPE_REGEX = T.let(/^\##{METHOD_NAME_REGEX}(?:\s*\&\s*\##{METHOD_NAME_REGEX})*$/, T.untyped)
     ORDERED_LIST_REGEX = T.let(/^(?:Array|)\((.*)\s*\)$/, T.untyped)
     SHORTHAND_HASH_SYNTAX = T.let(/^{\s*(.*)\s*}$/, T.untyped)
     SHORTHAND_ARRAY_SYNTAX = T.let(/^<\s*(.*)\s*>$/, T.untyped)
     SINGLE_ARG_GENERIC_TYPES = T.let(%w{Array Set Enumerable Enumerator Range}, T.untyped)
+    DUCK_TYPES_TO_RBS_TYPE_NAMES = T.let({
+  # Concrete
+  "#to_i" => "_ToI",
+  "#to_int" => "_ToInt",
+  "#to_r" => "_ToR",
+  "#to_s" => "_ToS",
+  "#to_str" => "_ToStr",
+  "#to_proc" => "_ToProc",
+  "#to_path" => "_ToPath",
+  "#read" => "_Reader",
+  "#readpartial" => "_ReaderPartial",
+  "#write" => "_Writer",
+  "#rewind" => "_Rewindable",
+  "#to_io" => "_ToIO",
+  "#exception" => "_Exception",
+
+  # Generic - these will be put in a `Types::Raw`, so writing RBS syntax is a little devious,
+  # but by their nature we know they'll only be used in an RBS file, so it's probably fine
+  "#to_hash" => "_ToHash[untyped, untyped]",
+  "#each" => "_Each[untyped]",
+}, T.untyped)
 
     # Given a string of YARD type parameters (without angle brackets), splits
     # the string into an array of each type parameter.
@@ -331,29 +415,17 @@ module Sord
     def self.split_type_parameters(params); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    # sord warn - Parlour::Types::Type wasn't able to be resolved to a constant in this project
     # Converts a YARD type into a Parlour type.
     # 
     # _@param_ `yard` — The YARD type.
     # 
     # _@param_ `item` — The CodeObject which the YARD type is associated with. This is used for logging and can be nil, but this will lead to less informative log messages.
     # 
-    # _@param_ `replace_errors_with_untyped` — If true, T.untyped is used instead of SORD_ERROR_ constants for unknown types.
-    # 
-    # _@param_ `replace_unresolved_with_untyped` — If true, T.untyped is used when Sord is unable to resolve a constant.
-    sig do
-      params(
-        yard: T.any(T::Boolean, T::Array[T.untyped], String),
-        item: T.nilable(YARD::CodeObjects::Base),
-        replace_errors_with_untyped: T::Boolean,
-        replace_unresolved_with_untyped: T::Boolean
-      ).returns(Parlour::Types::Type)
-    end
-    def self.yard_to_parlour(yard, item = nil, replace_errors_with_untyped = false, replace_unresolved_with_untyped = false); end
+    # _@param_ `config` — The generation configuration.
+    sig { params(yard: T.any(T::Boolean, T::Array[T.untyped], String), item: YARD::CodeObjects::Base, config: Configuration).returns(Parlour::Types::Type) }
+    def self.yard_to_parlour(yard, item, config); end
 
-    # sord warn - Parlour::Types::Type wasn't able to be resolved to a constant in this project
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    # sord warn - Parlour::Types::Type wasn't able to be resolved to a constant in this project
     # Handles SORD_ERRORs.
     # 
     # _@param_ `name`
@@ -372,5 +444,40 @@ module Sord
       ).returns(Parlour::Types::Type)
     end
     def self.handle_sord_error(name, log_warning, item, replace_errors_with_untyped); end
+
+    # Given a YARD duck type string, attempts to convert it to one of a list of pre-defined RBS
+    # built-in interfaces.
+    # 
+    # For example, the common duck type `#to_s` has a built-in RBS equivalent `_ToS`.
+    # 
+    # If no such interface exists, returns `nil`.
+    # 
+    # _@param_ `type`
+    sig { params(type: String).returns(T.nilable(Parlour::Types::Type)) }
+    def self.duck_type_to_rbs_type(type); end
+
+    # Configuration for how the type converter should work in particular cases.
+    class Configuration
+      # sord omit - no YARD type given for "replace_errors_with_untyped:", using untyped
+      # sord omit - no YARD type given for "replace_unresolved_with_untyped:", using untyped
+      # sord omit - no YARD type given for "output_language:", using untyped
+      sig { params(replace_errors_with_untyped: T.untyped, replace_unresolved_with_untyped: T.untyped, output_language: T.untyped).void }
+      def initialize(replace_errors_with_untyped:, replace_unresolved_with_untyped:, output_language:); end
+
+      # sord omit - no YARD type given for :output_language, using untyped
+      # The language which the generated types will be converted to - one of
+      # `:rbi` or `:rbs`.
+      sig { returns(T.untyped) }
+      attr_accessor :output_language
+
+      # _@return_ — If true, T.untyped is used instead of SORD_ERROR_
+      # constants for unknown types.
+      sig { returns(T::Boolean) }
+      attr_accessor :replace_errors_with_untyped
+
+      # _@param_ `replace_unresolved_with_untyped` — If true, T.untyped is used when Sord is unable to resolve a constant.
+      sig { returns(T::Boolean) }
+      attr_accessor :replace_unresolved_with_untyped
+    end
   end
 end

data/sord.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'sorbet-runtime'
   spec.add_dependency 'commander', '~> 4.5'
   spec.add_dependency 'parlour', '~> 5.0'
+  spec.add_dependency 'rbs', '~> 2.0'
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sord
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-19 00:00:00.000000000 Z
+date: 2022-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement