sord 0.8.0 → 0.9.0

data/lib/sord/rbi_generator.rb

@@ -1,15 +1,13 @@
 # typed: true
 require 'yard'
 require 'sord/type_converter'
-require 'colorize'
 require 'sord/logging'
+require 'parlour'
+require 'rainbow'
 
 module Sord
   # Converts the current working directory's YARD registry into an RBI file.
-  class RbiGenerator
-    # @return [Array<String>] The lines of the generated RBI file so far.
-    attr_reader :rbi_contents
-    
+  class RbiGenerator    
     # @return [Integer] The number of objects this generator has processed so 
     #   far.
     def object_count
@@ -21,35 +19,35 @@ module Sord
     #   [message, item, line].
     attr_reader :warnings
 
-    # @return [Boolean] A boolean indicating whether the next item is the first
-    #   in its namespace. This is used to determine whether to insert a blank
-    #   line before it or not.
-    attr_accessor :next_item_is_first_in_namespace
-
     # Create a new RBI generator.
     # @param [Hash] options
     # @option options [Integer] break_params
     # @option options [Boolean] replace_errors_with_untyped
+    # @option options [Boolean] replace_unresolved_with_untyped
     # @option options [Boolean] comments
+    # @option options [Parlour::RbiGenerator] generator
+    # @option options [Parlour::RbiGenerator::Namespace] root
     # @return [void]
     def initialize(options)
-      @rbi_contents = ['# typed: strong']
+      @parlour = options[:parlour] || Parlour::RbiGenerator.new
+      @current_object = options[:root] || @parlour.root
+
       @namespace_count = 0
       @method_count = 0
-      @break_params = options[:break_params]
-      @replace_errors_with_untyped = options[:replace_errors_with_untyped]
       @warnings = []
-      @next_item_is_first_in_namespace = true
+
+      @replace_errors_with_untyped = options[:replace_errors_with_untyped]
+      @replace_unresolved_with_untyped = options[:replace_unresolved_with_untyped]
 
       # Hook the logger so that messages are added as comments to the RBI file
-      Logging.add_hook do |type, msg, item, indent_level = 0|
-        rbi_contents << "#{'  ' * (indent_level + 1)}# sord #{type} - #{msg}"
+      Logging.add_hook do |type, msg, item|
+        @current_object.add_comment_to_next_child("sord #{type} - #{msg}")
       end if options[:comments]
 
       # Hook the logger so that warnings are collected
-      Logging.add_hook do |type, msg, item, indent_level = 0|
-        warnings << [msg, item, rbi_contents.length] \
-          if type == :warn
+      Logging.add_hook do |type, msg, item|
+        # TODO: is it possible to get line numbers here?
+        warnings << [msg, item, 0] if type == :warn
       end
     end
 
@@ -65,66 +63,41 @@ module Sord
       @method_count += 1
     end
 
-    # Adds a single blank line to the RBI file, unless this item is the first
-    # in its namespace.
-    # @return [void]
-    def add_blank
-      rbi_contents << '' unless next_item_is_first_in_namespace
-      self.next_item_is_first_in_namespace = false
-    end
-
     # Given a YARD CodeObject, add lines defining its mixins (that is, extends
     # and includes) to the current RBI file. Returns the number of mixins.
     # @param [YARD::CodeObjects::Base] item
-    # @param [Integer] indent_level
     # @return [Integer]
-    def add_mixins(item, indent_level)
-      includes = item.instance_mixins
-      extends = item.class_mixins
-
-      extends.reverse_each do |this_extend|
-        rbi_contents << "#{'  ' * (indent_level + 1)}extend #{this_extend.path}"
+    def add_mixins(item)
+      item.instance_mixins.reverse_each do |i|
+        @current_object.create_include(i.path.to_s)
       end
-      includes.reverse_each do |this_include|
-        rbi_contents << "#{'  ' * (indent_level + 1)}include #{this_include.path}"
+      item.class_mixins.reverse_each do |e|
+        @current_object.create_extend(e.path.to_s)
       end
 
-      extends.length + includes.length
+      item.instance_mixins.length + item.class_mixins.length
     end
 
-    # Given an array of parameters and a return type, inserts the signature for
-    # a method with those properties into the current RBI file.
-    # @param [Array<String>] params
-    # @param [String] returns
-    # @param [Integer] indent_level
+    # Given a YARD NamespaceObject, add lines defining constants.
+    # @param [YARD::CodeObjects::NamespaceObject] item
     # @return [void]
-    def add_signature(params, returns, indent_level)
-      if params.empty?
-        rbi_contents << "#{'  ' * (indent_level + 1)}sig { #{returns} }"
-        return
-      end
-
-      if params.length >= @break_params
-        rbi_contents << "#{'  ' * (indent_level + 1)}sig do"
-        rbi_contents << "#{'  ' * (indent_level + 2)}params("
-        params.each.with_index do |param, i|
-          terminator = params.length - 1 == i ? '' : ','
-          rbi_contents << "#{'  ' * (indent_level + 3)}#{param}#{terminator}"
-        end
-        rbi_contents << "#{'  ' * (indent_level + 2)}).#{returns}"
-        rbi_contents << "#{'  ' * (indent_level + 1)}end"
-      else
-        rbi_contents << "#{'  ' * (indent_level + 1)}sig { params(#{params.join(', ')}).#{returns} }"
+    def add_constants(item)
+      item.constants.each do |constant|
+        # 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
+        
+        # Add the constant to the current object being generated.
+        @current_object.create_constant(constant_name, value: "T.let(#{constant.value}, T.untyped)")
       end
     end
 
     # Given a YARD NamespaceObject, add lines defining its methods and their
     # signatures to the current RBI file.
     # @param [YARD::CodeObjects::NamespaceObject] item
-    # @param [Integer] indent_level
     # @return [void]
-    def add_methods(item, indent_level)
-      item.meths.each do |meth|
+    def add_methods(item)
+      item.meths(inherited: false).each do |meth|
         count_method
 
         # If the method is an alias, skip it so we don't define it as a
@@ -133,39 +106,20 @@ module Sord
           next
         end
 
-        add_blank
-
-        parameter_list = meth.parameters.map do |name, default|
-          # Handle these three main cases:
-          # - def method(param) or def method(param:)
-          # - def method(param: 'default')
-          # - def method(param = 'default')
-          if default.nil?
-            "#{name}"
-          elsif !default.nil? && name.end_with?(':')
-            "#{name} #{default}"
-          else
-            "#{name} = #{default}"
-          end
-        end.join(", ")
-
         # 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_to_tags = meth.parameters.map do |name, _|
-          [name, meth.tags('param')
-            .find { |p| p.name&.gsub('*', '') == name.gsub('*', '') }]
+        parameter_names_and_defaults_to_tags = meth.parameters.map do |name, default|
+          [[name, default], meth.tags('param')
+            .find { |p| p.name&.gsub('*', '')&.gsub(':', '') == name.gsub('*', '').gsub(':', '') }]
         end.to_h
 
-        sig_params_list = parameter_names_to_tags.map do |name, tag|
-          name = name.gsub('*', '')
+        parameter_types = parameter_names_and_defaults_to_tags.map do |name_and_default, tag|
+          name = name_and_default.first
 
           if tag
-            "#{name}: #{TypeConverter.yard_to_sorbet(tag.types, meth, indent_level, @replace_errors_with_untyped)}"
+            TypeConverter.yard_to_sorbet(tag.types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
           elsif name.start_with? '&'
-            # Cut the ampersand from the block parameter name
-            name = name.gsub('&', '')
-
             # Find yieldparams and yieldreturn
             yieldparams = meth.tags('yieldparam')
             yieldreturn = meth.tag('yieldreturn')&.types
@@ -174,17 +128,17 @@ module Sord
 
             # Create strings
             params_string = yieldparams.map do |param|
-              "#{param.name.gsub('*', '')}: #{TypeConverter.yard_to_sorbet(param.types, meth, indent_level, @replace_errors_with_untyped)}" unless param.name.nil?
+              "#{param.name.gsub('*', '')}: #{TypeConverter.yard_to_sorbet(param.types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)}" unless param.name.nil?
             end.join(', ')
-            return_string = TypeConverter.yard_to_sorbet(yieldreturn, meth, indent_level, @replace_errors_with_untyped)
+            return_string = TypeConverter.yard_to_sorbet(yieldreturn, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
 
             # Create proc types, if possible
             if yieldparams.empty? && yieldreturn.nil?
-              "#{name}: T.untyped"
+              'T.untyped'
             elsif yieldreturn.nil?
-              "#{name}: T.proc#{params_string.empty? ? '' : ".params(#{params_string})"}.void"
+              "T.proc#{params_string.empty? ? '' : ".params(#{params_string})"}.void"
             else
-              "#{name}: T.proc#{params_string.empty? ? '' : ".params(#{params_string})"}.returns(#{return_string})"
+              "T.proc#{params_string.empty? ? '' : ".params(#{params_string})"}.returns(#{return_string})"
             end
           elsif meth.path.end_with? '='
             # Look for the matching getter method
@@ -192,114 +146,126 @@ module Sord
             getter = item.meths.find { |m| m.path == getter_path }
 
             unless getter
-              if parameter_names_to_tags.length == 1 \
+              if parameter_names_and_defaults_to_tags.length == 1 \
                 && meth.tags('param').length == 1 \
                 && meth.tag('param').types
   
-                Logging.infer("argument name in single @param inferred as #{parameter_names_to_tags.first.first.inspect}", meth, indent_level)
-                next "#{name}: #{TypeConverter.yard_to_sorbet(meth.tag('param').types, meth, indent_level, @replace_errors_with_untyped)}"
+                Logging.infer("argument name in single @param inferred as #{parameter_names_and_defaults_to_tags.first.first.first.inspect}", meth)
+                next TypeConverter.yard_to_sorbet(meth.tag('param').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
               else  
-                Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth, indent_level)
-                next "#{name}: T.untyped"
+                Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+                next 'T.untyped'
               end
             end
 
             inferred_type = TypeConverter.yard_to_sorbet(
-              getter.tags('return').flat_map(&:types), meth, indent_level, @replace_errors_with_untyped)
+              getter.tags('return').flat_map(&:types), meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
             
-            Logging.infer("inferred type of parameter #{name.inspect} as #{inferred_type} using getter's return type", meth, indent_level)
-            # Get rid of : on keyword arguments.
-            name = name.chop if name.end_with?(':')
-            "#{name}: #{inferred_type}"
+            Logging.infer("inferred type of parameter #{name.inspect} as #{inferred_type} using getter's return type", meth)
+            inferred_type
           else
             # Is this the only argument, and was a @param specified without an
             # argument name? If so, infer it
-            if parameter_names_to_tags.length == 1 \
+            if parameter_names_and_defaults_to_tags.length == 1 \
               && meth.tags('param').length == 1 \
               && meth.tag('param').types
 
-              Logging.infer("argument name in single @param inferred as #{parameter_names_to_tags.first.first.inspect}", meth, indent_level)
-              "#{name}: #{TypeConverter.yard_to_sorbet(meth.tag('param').types, meth, indent_level, @replace_errors_with_untyped)}"
+              Logging.infer("argument name in single @param inferred as #{parameter_names_and_defaults_to_tags.first.first.first.inspect}", meth)
+              TypeConverter.yard_to_sorbet(meth.tag('param').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
             else
-              Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth, indent_level)
-              # Get rid of : on keyword arguments.
-              name = name.chop if name.end_with?(':')
-              "#{name}: T.untyped"
+              Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+              'T.untyped'
             end
           end
         end
 
         return_tags = meth.tags('return')
         returns = if return_tags.length == 0
-          Logging.omit("no YARD return type given, using T.untyped", meth, indent_level)
-          "returns(T.untyped)"
+          Logging.omit("no YARD return type given, using T.untyped", meth)
+          'T.untyped'
         elsif return_tags.length == 1 && return_tags&.first&.types&.first&.downcase == "void"
-          "void"
+          nil
         else
-          "returns(#{TypeConverter.yard_to_sorbet(meth.tag('return').types, meth, indent_level, @replace_errors_with_untyped)})"
+          TypeConverter.yard_to_sorbet(meth.tag('return').types, meth, @replace_errors_with_untyped, @replace_unresolved_with_untyped)
         end
 
-        prefix = meth.scope == :class ? 'self.' : ''
-
-        add_signature(sig_params_list, returns, indent_level)
+        parlour_params = parameter_names_and_defaults_to_tags
+          .zip(parameter_types)
+          .map do |((name, default), _), type|
+            # If the default is "nil" but the type is not nilable, then it 
+            # should become nilable
+            # (T.untyped can include nil, so don't alter that)
+            type = "T.nilable(#{type})" \
+              if default == 'nil' && !type.start_with?('T.nilable') && type != 'T.untyped'
+            Parlour::RbiGenerator::Parameter.new(
+              name.to_s,
+              type: type,
+              default: default
+            )
+          end
 
-        rbi_contents << "#{'  ' * (indent_level + 1)}def #{prefix}#{meth.name}(#{parameter_list}); end"
+        @current_object.create_method(
+          meth.name.to_s, 
+          parameters: parlour_params,
+          returns: returns,
+          class_method: meth.scope == :class
+        )
       end
     end
 
     # Given a YARD NamespaceObject, add lines defining its mixins, methods
     # and children to the RBI file.
     # @param [YARD::CodeObjects::NamespaceObject] item
-    # @param [Integer] indent_level
     # @return [void]
-    def add_namespace(item, indent_level = 0)
+    def add_namespace(item)
       count_namespace
-      add_blank
 
-      if item.type == :class && item.superclass.to_s != "Object"
-        rbi_contents << "#{'  ' * indent_level}class #{item.name} < #{item.superclass.path}" 
-      else
-        rbi_contents << "#{'  ' * indent_level}#{item.type} #{item.name}"
-      end
+      superclass = nil
+      superclass = item.superclass.path.to_s if item.type == :class && item.superclass.to_s != "Object"
 
-      self.next_item_is_first_in_namespace = true
-      if add_mixins(item, indent_level) > 0
-        self.next_item_is_first_in_namespace = false
-      end
-      add_methods(item, indent_level)
+      parent = @current_object
+      @current_object = item.type == :class \
+        ? parent.create_class(item.name.to_s, superclass: superclass)
+        : parent.create_module(item.name.to_s)
 
-      item.children.select { |x| [:class, :module].include?(x.type) }
-        .each { |child| add_namespace(child, indent_level + 1) }
+      add_mixins(item)
+      add_methods(item)
+      add_constants(item)
 
-      self.next_item_is_first_in_namespace = false
+      item.children.select { |x| [:class, :module].include?(x.type) }
+        .each { |child| add_namespace(child) }
 
-      rbi_contents << "#{'  ' * indent_level}end"
+      @current_object = parent
     end
 
-    # Generates the RBI file from the loading registry and returns its contents.
-    # You must load a registry first!
-    # @return [String]
-    def generate
+    # Populates the RBI generator with the contents of the YARD registry. You 
+    # must load the YARD registry first!
+    # @return [void]
+    def populate
       # Generate top-level modules, which recurses to all modules
       YARD::Registry.root.children
         .select { |x| [:class, :module].include?(x.type) }
         .each { |child| add_namespace(child) }
+      end
 
-      rbi_contents.join("\n")
+    # Populates the RBI generator with the contents of the YARD registry, then
+    # uses the loaded Parlour::RbiGenerator to generate the RBI file. You must
+    # load the YARD registry first!
+    # @return [void]
+    def generate
+      populate
+      @parlour.rbi
     end
 
-    # Generates the RBI file and writes it to the given file path, printing a
-    # summary and any warnings at the end. The registry is also loaded.
-    # @param [String, nil] filename
+    # Loads the YARD registry, populates the RBI file, and prints any relevant
+    # final logs.
     # @return [void]
-    def run(filename)
-      raise 'No filename specified' unless filename
-
+    def run
       # Get YARD ready
       YARD::Registry.load!
 
-      # Write the file
-      File.write(filename, generate)
+      # Populate the RBI
+      populate
 
       if object_count.zero?
         Logging.warn("No objects processed.")
@@ -318,10 +284,10 @@ module Sord
         else
           Logging.warn("The types which caused them have been replaced with SORD_ERROR_ constants.")
         end
-        Logging.warn("Please edit the file near the line numbers given to fix these errors.")
+        Logging.warn("Please edit the file to fix these errors.")
         Logging.warn("Alternatively, edit your YARD documentation so that your types are valid and re-run Sord.")
-        warnings.each do |(msg, item, line)|
-          puts "        #{"Line #{line} |".light_black} (#{item&.path&.bold}) #{msg}"
+        warnings.each do |(msg, item, _)|
+          puts "        (#{Rainbow(item&.path).bold}) #{msg}"
         end
       end
     rescue

data/lib/sord/resolver.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'stringio'
 
 module Sord
@@ -50,12 +51,18 @@ module Sord
     # @param [Object] item
     # @return [Boolean]
     def self.resolvable?(name, item)
-      name_parts = name.split('::')
-
       current_context = item
       current_context = current_context.parent \
         until current_context.is_a?(YARD::CodeObjects::NamespaceObject)
 
+      # If there is any matching object directly in the heirarchy, this is
+      # always true. Ruby can do the resolution.
+      unless name.include?('::')
+        return true if current_context.path.split('::').include?(name)
+      end
+
+      name_parts = name.split('::')
+
       matching_paths = []
 
       loop do

data/lib/sord/type_converter.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'yaml'
 require 'sord/logging'
 require 'sord/resolver'
@@ -94,11 +95,12 @@ module Sord
     # @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 [Integer] indent_level 
     # @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.
     # @return [String]
-    def self.yard_to_sorbet(yard, item = nil, indent_level = 0, replace_errors_with_untyped = false)
+    def self.yard_to_sorbet(yard, item = nil, replace_errors_with_untyped = false, replace_unresolved_with_untyped = false)
       case yard
       when nil # Type not specified
         "T.untyped"
@@ -111,15 +113,20 @@ module Sord
         # selection of any of the types
         types = yard
           .reject { |x| x == 'nil' }
-          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+          .map { |x| yard_to_sorbet(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
           .uniq
         result = types.length == 1 ? types.first : "T.any(#{types.join(', ')})"
         result = "T.nilable(#{result})" if yard.include?('nil')
         result
       when /^#{SIMPLE_TYPE_REGEX}$/
+        if SORBET_SINGLE_ARG_GENERIC_TYPES.include?(yard)
+          return "T::#{yard}[T.untyped]"
+        elsif yard == "Hash"
+          return "T::Hash[T.untyped, T.untyped]"
+        end
         # If this doesn't begin with an uppercase letter, warn
         if /^[_a-z]/ === yard
-          Logging.warn("#{yard} is probably not a type, but using anyway", item, indent_level)
+          Logging.warn("#{yard} is probably not a type, but using anyway", item)
         end
 
         # Check if whatever has been specified is actually resolvable; if not,
@@ -127,18 +134,23 @@ module Sord
         if item && !Resolver.resolvable?(yard, item)
           if Resolver.path_for(yard)
             new_path = Resolver.path_for(yard)
-            Logging.infer("#{yard} was resolved to #{new_path}", item, indent_level) \
+            Logging.infer("#{yard} was resolved to #{new_path}", item) \
               unless yard == new_path
             new_path
           else
-            Logging.warn("#{yard} wasn't able to be resolved to a constant in this project", item, indent_level)
-            yard
+            if replace_unresolved_with_untyped
+              Logging.warn("#{yard} wasn't able to be resolved to a constant in this project, replaced with T.untyped", item)
+              'T.untyped'
+            else
+              Logging.warn("#{yard} wasn't able to be resolved to a constant in this project", item)
+              yard
+            end
           end
         else
           yard
         end
       when DUCK_TYPE_REGEX
-        Logging.duck("#{yard} looks like a duck type, replacing with T.untyped", item, indent_level)
+        Logging.duck("#{yard} looks like a duck type, replacing with T.untyped", item)
         'T.untyped'
       when /^#{GENERIC_TYPE_REGEX}$/
         generic_type = $1
@@ -146,46 +158,72 @@ module Sord
 
         if SORBET_SUPPORTED_GENERIC_TYPES.include?(generic_type)
           parameters = split_type_parameters(type_parameters)
-            .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+            .map { |x| yard_to_sorbet(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
           if SORBET_SINGLE_ARG_GENERIC_TYPES.include?(generic_type) && parameters.length > 1
             "T::#{generic_type}[T.any(#{parameters.join(', ')})]"
           elsif generic_type == 'Class' && parameters.length == 1
             "T.class_of(#{parameters.first})"
+          elsif generic_type == 'Hash'
+            if parameters.length == 2
+              "T::Hash[#{parameters.join(', ')}]"
+            else
+              handle_sord_error(parameters.join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, replace_errors_with_untyped)
+            end
           else
             "T::#{generic_type}[#{parameters.join(', ')}]"
           end
         else
-          Logging.warn("unsupported generic type #{generic_type.inspect} in #{yard.inspect}", item, indent_level)
-          replace_errors_with_untyped ? "T.untyped" : "SORD_ERROR_#{generic_type.gsub(/[^0-9A-Za-z_]/i, '')}"
+          return handle_sord_error(
+            generic_type,
+            "unsupported generic type #{generic_type.inspect} in #{yard.inspect}",
+            item,
+            replace_errors_with_untyped
+          )
         end
       # Converts ordered lists like Array(Symbol, String) or (Symbol, String)
       # into Sorbet Tuples like [Symbol, String].
       when ORDERED_LIST_REGEX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+          .map { |x| yard_to_sorbet(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
         "[#{parameters.join(', ')}]"
       when SHORTHAND_HASH_SYNTAX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
-        "T::Hash<#{parameters.join(', ')}>"
+          .map { |x| yard_to_sorbet(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
+        # Return a warning about an invalid hash when it has more or less than two elements.
+        if parameters.length == 2
+          "T::Hash[#{parameters.join(', ')}]"
+        else
+          handle_sord_error(parameters.join, "Invalid hash, must have exactly two types: #{yard.inspect}.", item, replace_errors_with_untyped)
+        end
       when SHORTHAND_ARRAY_SYNTAX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+          .map { |x| yard_to_sorbet(x, item, replace_errors_with_untyped, replace_unresolved_with_untyped) }
         parameters.one? \
-          ? "T::Array<#{parameters.first}>"
-          : "T::Array<T.any(#{parameters.join(', ')})>"
+          ? "T::Array[#{parameters.first}]"
+          : "T::Array[T.any(#{parameters.join(', ')})]"
       else
         # Check for literals
         from_yaml = YAML.load(yard) rescue nil
         return from_yaml.class.to_s \
           if [Symbol, Float, Integer].include?(from_yaml.class)
 
-        Logging.warn("#{yard.inspect} does not appear to be a type", item, indent_level)
-        replace_errors_with_untyped ? "T.untyped" : "SORD_ERROR_#{yard.gsub(/[^0-9A-Za-z_]/i, '')}"
+        return handle_sord_error(yard.to_s, "#{yard.inspect} does not appear to be a type", item, replace_errors_with_untyped)
       end
     end
+
+    # Handles SORD_ERRORs.
+    #
+    # @param [String] name
+    # @param [String] log_warning
+    # @param [YARD::CodeObjects::Base] item
+    # @param [Boolean] replace_errors_with_untyped
+    # @return [String]
+    def self.handle_sord_error(name, log_warning, item, replace_errors_with_untyped)
+      Logging.warn(log_warning, item)
+      return replace_errors_with_untyped ? "T.untyped" : "SORD_ERROR_#{name.gsub(/[^0-9A-Za-z_]/i, '')}"
+    end
   end
 end

data/lib/sord/version.rb

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

data/lib/sord.rb

@@ -1,5 +1,6 @@
 # typed: strong
 require 'sord/version'
 require 'sord/rbi_generator'
+require 'sord/parlour_plugin'
 require 'yard'
 require 'sorbet-runtime'