parlour 2.0.0 → 5.0.0.beta.1

data/lib/parlour/rbs_generator/parameter.rb

@@ -0,0 +1,145 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a method parameter with a Sorbet type signature.
+    class Parameter
+      extend T::Sig
+
+      sig do
+        params(
+          name: String,
+          type: T.nilable(Types::TypeLike),
+          required: T::Boolean,
+        ).void
+      end
+      # Create a new method parameter.
+      # Note that, in RBS, blocks are not parameters. Use a {Block} instead.
+      #
+      # @example Create a simple Integer parameter named +num+.
+      #   Parlour::RbsGenerator::Parameter.new('num', type: 'Integer')
+      # @example Create a nilable array parameter.
+      #   Parlour::RbsGenerator::Parameter.new('array_of_strings_or_symbols', type:
+      #     Parlour::Types::Nilable.new(
+      #       Parlour::Types::Array.new(
+      #         Parlour::Types::Union.new('String', 'Symbol')
+      #       )
+      #     )
+      #   )
+      # @example Create an optional parameter.
+      #   Parlour::RbsGenerator::Parameter.new('name', type: 'String', default: 'Parlour')
+      #
+      # @param name [String] The name of this parameter. This may start with +*+ or +**+,
+      #   ,or end with +:+, which will infer the {kind} of this
+      #   parameter. (If it contains none of those, {kind} will be +:normal+.)
+      # @param type [Types::TypeLike, nil] This type of this parameter.
+      # @param required [Boolean] Whether this parameter is required.
+      # @return [void]
+      def initialize(name, type: nil, required: true)
+        name = T.must(name)
+        @name = name
+
+        prefix = /^(\*\*|\*|\&)?/.match(name)&.captures&.first || ''
+        @kind = PREFIXES.rassoc(prefix).first
+
+        @kind = :keyword if kind == :normal && name.end_with?(':')
+
+        @type = type || Parlour::Types::Untyped.new
+        @required = required
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another method.
+      #
+      # @param other [Object] The other instance. If this is not a {Parameter} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        Parameter === other &&
+          name    == other.name &&
+          kind    == other.kind &&
+          type    == other.type &&
+          required == other.required
+      end
+
+      sig { returns(String) }
+      # The name of this parameter, including any prefixes or suffixes such as
+      # +*+.
+      # @return [String]
+      attr_reader :name
+
+      sig { returns(String) }
+      # The name of this parameter, stripped of any prefixes or suffixes. For
+      # example, +*rest+ would become +rest+, or +foo:+ would become +foo+.
+      #
+      # @return [String]
+      def name_without_kind
+        return T.must(name[0..-2]) if kind == :keyword
+
+        prefix_match = /^(\*\*|\*|\&)?[a-zA-Z_]/.match(name)
+        raise 'unknown prefix' unless prefix_match
+        prefix = prefix_match.captures.first || ''
+        T.must(name[prefix.length..-1])
+      end
+
+      sig { returns(Types::TypeLike) }
+      # This parameter's type.
+      # @return [String]
+      attr_reader :type
+
+      sig { returns(T::Boolean) }
+      # Whether this parameter is required.
+      # @return [Boolean]
+      attr_reader :required
+
+      sig { returns(Symbol) }
+      # The kind of parameter that this is. This will be one of +:normal+, 
+      # +:splat+, +:double_splat+, or +:keyword+.
+      # @return [Symbol]
+      attr_reader :kind
+
+      # An array of reserved keywords in RBS which may be used as parameter
+      # names in standard Ruby.
+      # TODO: probably incomplete
+      RBS_KEYWORDS = [
+        'type', 'interface', 'out', 'in', 'instance'
+      ]
+
+      # A mapping of {kind} values to the characteristic prefixes each kind has.
+      PREFIXES = {
+        normal: '',
+        splat: '*',
+        double_splat: '**',
+      }.freeze      
+
+      sig { returns(String) }
+      # A string of how this parameter should be defined in an RBS signature.
+      #
+      # @return [String]
+      def to_rbs_param
+        raise 'blocks are not parameters in RBS' if kind == :block
+
+        t = String === @type ? @type : @type.generate_rbs
+        t = "^#{t}" if Types::Proc === @type
+
+        if RBS_KEYWORDS.include? name_without_kind
+          unless $VERBOSE.nil?
+            print Rainbow("Parlour warning: ").yellow.dark.bold
+            print Rainbow("Type generalization: ").magenta.bright.bold
+            puts "'#{name_without_kind}' is a keyword in RBS, renaming method parameter to '_#{name_without_kind}'"
+          end
+          
+          n = "_#{name_without_kind}"
+        else
+          n = name_without_kind
+        end
+
+        # Extra check because "?*something" is invalid
+        ((required || (kind != :normal && kind != :keyword)) ? '' : '?') + if kind == :keyword
+          "#{n}: #{t}"
+        else
+          "#{PREFIXES[kind]}#{t} #{n}"
+        end
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/rbs_object.rb

@@ -0,0 +1,78 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # An abstract class which is subclassed by any classes which can generate
+    # entire lines of an RBS, such as {Namespace} and {Method}. (As an example,
+    # {Parameter} is _not_ a subclass because it does not generate lines, only
+    # segments of definition lines.)
+    # @abstract
+    class RbsObject < TypedObject
+      abstract!
+      
+      sig { params(generator: Generator, name: String).void }
+      # Creates a new RBS object.
+      # @note Don't call this directly.
+      #
+      # @param generator [RbsGenerator] The current RbsGenerator.
+      # @param name [String] The name of this module.
+      # @return [void]
+      def initialize(generator, name)
+        super(name)
+        @generator = generator
+        @generated_by = RbsGenerator === generator ? generator.current_plugin : nil
+      end
+
+      sig { returns(Generator) }
+      # The generator which this object belongs to.
+      # @return [Generator]
+      attr_reader :generator
+
+      sig do
+        abstract.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this object.
+      #
+      # @abstract
+      # @param indent_level [Integer] The indentation level to generate the lines at.
+      # @param options [Options] The formatting options to use.
+      # @return [Array<String>] The RBS lines, formatted as specified.
+      def generate_rbs(indent_level, options); end
+
+      sig do
+        abstract.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of other objects, returns true if they may be merged
+      # into this instance using {merge_into_self}. Each subclass will have its
+      # own criteria on what allows objects to be mergeable.
+      #
+      # @abstract
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {RbsObject} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others); end
+
+      sig do 
+        abstract.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of other objects, merges them into this one. Each
+      # subclass will do this differently.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @abstract
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {RbsObject} instances.
+      # @return [void]
+      def merge_into_self(others); end
+
+      sig { overridable.override.returns(String) }
+      def describe
+        'RBS object'
+      end  
+    end
+  end
+end

data/lib/parlour/rbs_generator/type_alias.rb

@@ -0,0 +1,96 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a type alias.
+    class TypeAlias < RbsObject
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: TypeAlias).void)
+        ).void
+      end
+      # Creates a new type alias.
+      #
+      # @param name [String] The name of the alias.
+      # @param value [String] The type to alias to.
+      def initialize(generator, name:, type:, &block)
+        super(generator, name)
+        @type = type
+        yield_self(&block) if block
+      end
+
+      # @return [String] The type to alias to.
+      sig { returns(Types::TypeLike) }
+      attr_reader :type
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another type alias.
+      #
+      # @param other [Object] The other instance. If this is not a {TypeAlias} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        TypeAlias === other && name == other.name && type == other.type
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this type alias.
+      #
+      # @param indent_level [Integer] The indentation level to generate the lines at.
+      # @param options [Options] The formatting options to use.
+      # @return [Array<String>] The RBS lines, formatted as specified.
+      def generate_rbs(indent_level, options)
+        [options.indented(indent_level,
+          "type #{name} = #{String === @type ? @type : @type.generate_rbs}"
+        )]
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {TypeAlias} instances, returns true if they may be 
+      # merged into this instance using {merge_into_self}. This is always false.
+      #
+      # @param others [Array<RbiGenerator::RbsObject>] An array of other
+      #   {TypeAlias} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others.all? { |other| self == other }
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {TypeAlias} instances, merges them into this one.
+      # This particular implementation will simply do nothing, as instances
+      # are only mergeable if they are indentical.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbiGenerator::RbsObject>] An array of other
+      #   {TypeAlias} instances.
+      # @return [void]
+      def merge_into_self(others)
+        # We don't need to change anything! We only merge identical type alias
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Type Alias (#{name} = #{type})"
+      end
+    end
+  end
+end

data/lib/parlour/type_loader.rb

@@ -10,27 +10,34 @@ module Parlour
     # TODO: make this into a class which stores configuration and passes it to
     # all typeparsers
 
-    sig { params(source: String, filename: T.nilable(String)).returns(RbiGenerator::Namespace) }
+    sig { params(source: String, filename: T.nilable(String), generator: T.nilable(RbiGenerator)).returns(RbiGenerator::Namespace) }
     # Converts Ruby source code into a tree of objects.
     #
     # @param [String] source The Ruby source code.
     # @param [String, nil] filename The filename to use when parsing this code.
     #   This may be used in error messages, but is optional.
     # @return [RbiGenerator::Namespace] The root of the object tree.
-    def self.load_source(source, filename = nil)
-      TypeParser.from_source(filename || '(source)', source).parse_all
+    def self.load_source(source, filename = nil, generator: nil)
+      TypeParser.from_source(filename || '(source)', source, generator: generator).parse_all
     end
 
-    sig { params(filename: String).returns(RbiGenerator::Namespace) }
+    sig { params(filename: String, generator: T.nilable(RbiGenerator)).returns(RbiGenerator::Namespace) }
     # Converts Ruby source code into a tree of objects from a file.
     #
     # @param [String] filename The name of the file to load code from.
     # @return [RbiGenerator::Namespace] The root of the object tree.
-    def self.load_file(filename)
-      load_source(File.read(filename), filename)
+    def self.load_file(filename, generator: nil)
+      load_source(File.read(filename), filename, generator: generator)
+    end
+
+    sig do
+      params(
+        root: String,
+        inclusions: T::Array[String],
+        exclusions: T::Array[String],
+        generator: T.nilable(RbiGenerator),
+      ).returns(RbiGenerator::Namespace)
     end
-  
-    sig { params(root: String).returns(RbiGenerator::Namespace) }
     # Loads an entire Sorbet project using Sorbet's file table, obeying any
     # "typed: ignore" sigils, into a tree of objects.
     #
@@ -39,8 +46,15 @@ module Parlour
     #
     # @param [String] root The root of the project; where the "sorbet" directory
     #   and "Gemfile" are located.
+    # @param [Array<String>] inclusions A list of files to include when loading
+    #   the project, relative to the given root.
+    # @param [Array<String>] exclusions A list of files to exclude when loading
+    #   the project, relative to the given root.
     # @return [RbiGenerator::Namespace] The root of the object tree.
-    def self.load_project(root)
+    def self.load_project(root, inclusions: ['.'], exclusions: [], generator: nil)
+      expanded_inclusions = inclusions.map { |i| File.expand_path(i, root) }
+      expanded_exclusions = exclusions.map { |e| File.expand_path(e, root) }
+
       stdin, stdout, stderr, wait_thr = T.unsafe(Open3).popen3(
         'bundle exec srb tc -p file-table-json',
         chdir: root
@@ -58,12 +72,18 @@ module Parlour
         next if rel_path.start_with?('./sorbet/rbi/hidden-definitions/')
         path = File.expand_path(rel_path, root)
 
+        # Skip this file if it was excluded
+        next if !expanded_inclusions.any? { |i| path.start_with?(i) } \
+          || expanded_exclusions.any? { |e| path.start_with?(e) }
+
         # There are some entries which are URLs to stdlib
         next unless File.exist?(path)
 
-        namespaces << load_file(path)
+        namespaces << load_file(path, generator: generator)
       end
 
+      namespaces.uniq!
+
       raise 'project is empty' if namespaces.empty?
 
       first_namespace, *other_namespaces = namespaces

data/lib/parlour/type_parser.rb

@@ -83,7 +83,7 @@ module Parlour
 
     extend T::Sig
 
-    sig { params(ast: Parser::AST::Node, unknown_node_errors: T::Boolean).void }
+    sig { params(ast: Parser::AST::Node, unknown_node_errors: T::Boolean, generator: T.nilable(RbiGenerator)).void }
     # Creates a new {TypeParser} from whitequark/parser AST.
     #
     # @param [Parser::AST::Node] The AST.
@@ -92,23 +92,26 @@ module Parlour
     #   if true, a parse error is raised. Setting this to true is likely to
     #   raise errors for lots of non-RBI Ruby code, but setting it to false
     #   could miss genuine typed objects if Parlour or your code contains a bug.
-    def initialize(ast, unknown_node_errors: false)
+    def initialize(ast, unknown_node_errors: false, generator: nil)
       @ast = ast
       @unknown_node_errors = unknown_node_errors
+      @generator = generator || DetachedRbiGenerator.new
     end
 
-    sig { params(filename: String, source: String).returns(TypeParser) }
+    sig { params(filename: String, source: String, generator: T.nilable(RbiGenerator)).returns(TypeParser) }
     # Creates a new {TypeParser} from a source file and its filename.
     #
     # @param [String] filename A filename. This does not need to be an actual
     #   file; it merely identifies this source.
     # @param [String] source The Ruby source code.
     # @return [TypeParser]
-    def self.from_source(filename, source)
+    def self.from_source(filename, source, generator: nil)
       buffer = Parser::Source::Buffer.new(filename)
       buffer.source = source
-      
-      TypeParser.new(Parser::CurrentRuby.new.parse(buffer))
+
+      # || special case handles parser returning nil on an empty file
+      parsed = Parser::CurrentRuby.new.parse(buffer) || Parser::AST::Node.new(:body)
+      TypeParser.new(parsed, generator: generator)
     end
 
     sig { returns(Parser::AST::Node) }
@@ -117,15 +120,19 @@ module Parlour
 
     sig { returns(T::Boolean) }
     # @return [Boolean] Whether to raise an error if a node of an unknown kind
-    #   is encountered. 
+    #   is encountered.
     attr_reader :unknown_node_errors
 
+    sig { returns(RbiGenerator) }
+    # @return [RbiGenerator] The {RbiGenerator} to load the source into.
+    attr_accessor :generator
+
     # Parses the entire source file and returns the resulting root namespace.
     #
     # @return [RbiGenerator::Namespace] The root namespace of the parsed source.
     sig { returns(RbiGenerator::Namespace) }
     def parse_all
-      root = RbiGenerator::Namespace.new(DetachedRbiGenerator.new)
+      root = generator.root
       root.children.concat(parse_path_to_object(NodePath.new([])))
       root
     end
@@ -134,7 +141,7 @@ module Parlour
     # represents and returns it, recursing to any child namespaces and parsing
     # any methods within.
     #
-    # If the node directly represents several nodes, such as being a 
+    # If the node directly represents several nodes, such as being a
     # (begin ...) node, they are all returned.
     #
     # @param [NodePath] path The path to the namespace definition. Do not pass
@@ -144,7 +151,7 @@ module Parlour
     sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::RbiObject]) }
     def parse_path_to_object(path, is_within_eigenclass: false)
       node = path.traverse(ast)
-      
+
       case node.type
       when :class
         parse_err 'cannot declare classes in an eigenclass', node if is_within_eigenclass
@@ -158,9 +165,9 @@ module Parlour
         *parent_names, this_name = constant_names(name)
         target = T.let(nil, T.nilable(RbiGenerator::Namespace))
         top_level = T.let(nil, T.nilable(RbiGenerator::Namespace))
-        parent_names.each do |n| 
+        parent_names.each do |n|
           new_obj = RbiGenerator::Namespace.new(
-            DetachedRbiGenerator.new,
+            generator,
             n.to_s,
             false,
           )
@@ -169,18 +176,103 @@ module Parlour
           top_level ||= new_obj
         end if parent_names
 
-        final_obj = RbiGenerator::ClassNamespace.new(
-          DetachedRbiGenerator.new,
-          this_name.to_s,
-          final,
-          node_to_s(superclass),
-          abstract,
-        ) do |c|
-          c.children.concat(parse_path_to_object(path.child(2))) if body
-          c.create_includes(includes)
-          c.create_extends(extends)
+        # Instantiate the correct kind of class
+        if ['T::Struct', '::T::Struct'].include?(node_to_s(superclass))
+          # Find all of this struct's props and consts
+          # The body is typically a `begin` element but when there's only
+          # one node there's no wrapping block and instead it would directly
+          # be the node.
+          prop_nodes = body.nil? ? [] :
+            (body.type == :begin ? body.to_a : [body]).select { |x| x.type == :send && [:prop, :const].include?(x.to_a[1]) }
+
+          props = prop_nodes.map do |prop_node|
+            _, prop_type, name_node, type_node, extras_hash_node = *prop_node
+
+            # "const" is just "prop ..., immutable: true"
+            extras_hash = extras_hash_node.to_a.map do |pair_node|
+              key_node, value_node = *pair_node
+              parse_err 'prop/const key must be a symbol', prop_node unless key_node.type == :sym
+              key = key_node.to_a.first
+
+              value =
+                if key == :default
+                  T.must(node_to_s(value_node))
+                else
+                  case value_node.type
+                  when :true
+                    true
+                  when :false
+                    false
+                  when :sym
+                    value_node.to_a.first
+                  else
+                    T.must(node_to_s(value_node))
+                  end
+                end
+
+              [key, value]
+            end.to_h
+
+            if prop_type == :const
+              parse_err 'const cannot use immutable key', prop_node unless extras_hash[:immutable].nil?
+              extras_hash[:immutable] = true
+            end
+
+            # Get prop/const name
+            parse_err 'prop/const name must be a symbol or string', prop_node unless [:sym, :str].include?(name_node.type)
+            name = name_node.to_a.first.to_s
+
+            RbiGenerator::StructProp.new(
+              name,
+              T.must(node_to_s(type_node)),
+              **T.unsafe(extras_hash)
+            )
+          end
+
+          final_obj = RbiGenerator::StructClassNamespace.new(
+            generator,
+            this_name.to_s,
+            final,
+            props,
+            abstract,
+          )
+        elsif ['T::Enum', '::T::Enum'].include?(node_to_s(superclass))
+          # Look for (block (send nil :enums) ...) structure
+          enums_node = body.nil? ? nil :
+            (body.type == :begin ? body.to_a : [body]).find { |x| x.type == :block && x.to_a[0].type == :send && x.to_a[0].to_a[1] == :enums }
+
+          # Find the constant assigments within this block
+          constant_nodes = enums_node.to_a[2].to_a
+
+          # Convert this to an array to enums as EnumClassNamespace expects
+          enums = constant_nodes.map do |constant_node|
+            _, name, new_node = *constant_node
+            serialize_value = node_to_s(new_node.to_a[2])
+
+            serialize_value ? [name.to_s, serialize_value] : name.to_s
+          end
+
+          final_obj = RbiGenerator::EnumClassNamespace.new(
+            generator,
+            this_name.to_s,
+            final,
+            enums,
+            abstract,
+          )
+        else
+          final_obj = RbiGenerator::ClassNamespace.new(
+            generator,
+            this_name.to_s,
+            final,
+            node_to_s(superclass),
+            abstract,
+          )
         end
 
+        final_obj.children.concat(parse_path_to_object(path.child(2))) if body
+        final_obj.create_includes(includes)
+        final_obj.create_extends(extends)
+
         if target
           target.children << final_obj
           [top_level]
@@ -199,9 +291,9 @@ module Parlour
         *parent_names, this_name = constant_names(name)
         target = T.let(nil, T.nilable(RbiGenerator::Namespace))
         top_level = T.let(nil, T.nilable(RbiGenerator::Namespace))
-        parent_names.each do |n| 
+        parent_names.each do |n|
           new_obj = RbiGenerator::Namespace.new(
-            DetachedRbiGenerator.new,
+            generator,
             n.to_s,
             false,
           )
@@ -211,7 +303,7 @@ module Parlour
         end if parent_names
 
         final_obj = RbiGenerator::ModuleNamespace.new(
-          DetachedRbiGenerator.new,
+          generator,
           this_name.to_s,
           final,
           interface,
@@ -230,24 +322,34 @@ module Parlour
       when :send, :block
         if sig_node?(node)
           parse_sig_into_methods(path, is_within_eigenclass: is_within_eigenclass)
+        elsif node.type == :send &&
+            [:attr_reader, :attr_writer, :attr_accessor].include?(node.to_a[1]) &&
+            !previous_sibling_sig_node?(path)
+          parse_method_into_methods(path, is_within_eigenclass: is_within_eigenclass)
         else
           []
         end
       when :def, :defs
-        # TODO: Support for defs without sigs
-        #   If so, we need some kind of state machine to determine whether
-        #   they've already been dealt with by the "when :send" clause and 
-        #   #parse_sig_into_methods.
-        #   If not, just ignore this.
-        []
+        if previous_sibling_sig_node?(path)
+          []
+        else
+          parse_method_into_methods(path, is_within_eigenclass: is_within_eigenclass)
+        end
       when :sclass
         parse_err 'cannot access eigen of non-self object', node unless node.to_a[0].type == :self
         parse_path_to_object(path.child(1), is_within_eigenclass: true)
       when :begin
         # Just map over all the things
         node.to_a.length.times.map do |c|
-          parse_path_to_object(path.child(c), is_within_eigenclass: is_within_eigenclass) 
+          parse_path_to_object(path.child(c), is_within_eigenclass: is_within_eigenclass)
         end.flatten
+      when :casgn
+        _, name, body = *node
+        [Parlour::RbiGenerator::Constant.new(
+          generator,
+          name: T.must(name).to_s,
+          value: T.must(node_to_s(body)),
+        )]
       else
         if unknown_node_errors
           parse_err "don't understand node type #{node.type}", node
@@ -259,6 +361,7 @@ module Parlour
 
     # A parsed sig, not associated with a method.
     class IntermediateSig < T::Struct
+      prop :type_parameters, T.nilable(T::Array[Symbol])
       prop :overridable, T::Boolean
       prop :override, T::Boolean
       prop :abstract, T::Boolean
@@ -318,7 +421,18 @@ module Parlour
           arg.to_a
         end
 
+      # Find type parameters if they were used
+      type_parameters = sig_chain
+        .find { |(n, _)| n == :type_parameters }
+        &.then do |(_, a)|
+          a.map do |arg|
+            parse_err 'type parameter must be a symbol', arg if arg.type != :sym
+            arg.to_a[0]
+          end
+        end
+
       IntermediateSig.new(
+        type_parameters: type_parameters,
         overridable: overridable,
         override: override,
         abstract: abstract,
@@ -370,7 +484,7 @@ module Parlour
             || target != nil
 
         parse_err 'typed attribute should have at least one name', def_node if parameters&.length == 0
-        
+
         kind = :attr
         attr_direction = method_name.to_s.gsub('attr_', '').to_sym
         def_names = T.must(parameters).map { |param| param.to_a[0].to_s }
@@ -389,6 +503,13 @@ module Parlour
       return_type = this_sig.return_type
 
       if kind == :def
+        # Sorbet allows a trailing blockarg that's not in the sig
+        if params &&
+           def_params.length == params.length + 1 &&
+           def_params[-1].type == :blockarg
+          def_params = def_params[0...-1]
+        end
+
         parse_err 'mismatching number of arguments in sig and def', sig_block_node \
           if params && def_params.length != params.length
 
@@ -399,6 +520,7 @@ module Parlour
         parameters = params \
           ? zip_by(params, ->x{ x.to_a[0].to_a[0] }, def_params, ->x{ x.to_a[0] })
             .map do |sig_arg, def_param|
+
               arg_name = def_param.to_a[0]
 
               # TODO: anonymous restarg
@@ -418,10 +540,11 @@ module Parlour
         # There should only be one ever here, but future-proofing anyway
         def_names.map do |def_name|
           RbiGenerator::Method.new(
-            DetachedRbiGenerator.new,
+            generator,
             def_name,
             parameters,
             return_type,
+            type_parameters: this_sig.type_parameters,
             override: this_sig.override,
             overridable: this_sig.overridable,
             abstract: this_sig.abstract,
@@ -437,7 +560,7 @@ module Parlour
 
           parse_err "attr_#{attr_direction} sig should have non-void return", sig_block_node \
             unless return_type
-            
+
           attr_type = return_type
         when :writer
           # These are special and can only have one name
@@ -457,7 +580,111 @@ module Parlour
 
         def_names.map do |def_name|
           RbiGenerator::Attribute.new(
-            DetachedRbiGenerator.new,
+            generator,
+            def_name,
+            attr_direction,
+            attr_type,
+            class_attribute: class_method
+          )
+        end
+      else
+        raise "unknown definition kind #{kind}"
+      end
+    end
+
+    sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::Method]) }
+    # Given a path to a method in the AST, finds the associated definition and
+    # parses them into methods.
+    # Usually this will return one method; the only exception currently is for
+    # attributes, where multiple can be declared in one call, e.g.
+    # +attr_reader :x, :y, :z+.
+    #
+    # @param [NodePath] path The sig to parse.
+    # @param [Boolean] is_within_eigenclass Whether the method definition this sig is
+    #   associated with appears inside an eigenclass definition. If true, the
+    #   returned method is made a class method. If the method definition
+    #   is already a class method, an exception is thrown as the method will be
+    #   a class method of the eigenclass, which Parlour can't represent.
+    # @return [<RbiGenerator::Method>] The parsed methods.
+    def parse_method_into_methods(path, is_within_eigenclass: false)
+      # A :def node represents a definition like "def x; end"
+      # A :defs node represents a definition like "def self.x; end"
+      def_node = path.traverse(ast)
+      case def_node.type
+      when :def
+        class_method = false
+        def_names = [def_node.to_a[0].to_s]
+        def_params = def_node.to_a[1].to_a
+        kind = :def
+      when :defs
+        parse_err 'targeted definitions on a non-self target are not supported', def_node \
+          unless def_node.to_a[0].type == :self
+        class_method = true
+        def_names = [def_node.to_a[1].to_s]
+        def_params = def_node.to_a[2].to_a
+        kind = :def
+      when :send
+        target, method_name, *parameters = *def_node
+
+        parse_err 'node after a sig must be a method definition', def_node \
+          unless [:attr_reader, :attr_writer, :attr_accessor].include?(method_name) \
+            || target != nil
+
+        parse_err 'typed attribute should have at least one name', def_node if parameters&.length == 0
+
+        kind = :attr
+        attr_direction = method_name.to_s.gsub('attr_', '').to_sym
+        def_names = T.must(parameters).map { |param| param.to_a[0].to_s }
+        class_method = false
+      else
+        parse_err 'node after a sig must be a method definition', def_node
+      end
+
+      if is_within_eigenclass
+        parse_err 'cannot represent multiple levels of eigenclassing', def_node if class_method
+        class_method = true
+      end
+
+      return_type = "T.untyped"
+
+      if kind == :def
+        parameters = def_params.map do |def_param|
+          arg_name = def_param.to_a[0]
+
+          # TODO: anonymous restarg
+          full_name = arg_name.to_s
+          full_name = "*#{arg_name}"  if def_param.type == :restarg
+          full_name = "**#{arg_name}" if def_param.type == :kwrestarg
+          full_name = "#{arg_name}:"  if def_param.type == :kwarg || def_param.type == :kwoptarg
+          full_name = "&#{arg_name}"  if def_param.type == :blockarg
+
+          default = def_param.to_a[1] ? node_to_s(def_param.to_a[1]) : nil
+          type = nil
+
+          RbiGenerator::Parameter.new(full_name, type: type, default: default)
+        end
+
+        # There should only be one ever here, but future-proofing anyway
+        def_names.map do |def_name|
+          RbiGenerator::Method.new(
+            generator,
+            def_name,
+            parameters,
+            return_type,
+            class_method: class_method
+          )
+        end
+      elsif kind == :attr
+        case attr_direction
+        when :reader, :accessor, :writer
+          attr_type = return_type
+        else
+          raise "unknown attribute direction #{attr_direction}"
+        end
+
+        def_names.map do |def_name|
+          RbiGenerator::Attribute.new(
+            generator,
             def_name,
             attr_direction,
             attr_type,
@@ -469,14 +696,166 @@ module Parlour
       end
     end
 
+    sig { params(str: String).returns(Types::Type) }
+    # TODO doc
+    def self.parse_single_type(str)
+      i = TypeParser.from_source('(none)', str)
+      i.parse_node_to_type(i.ast)
+    end
+
+    sig { params(node: Parser::AST::Node).returns(Types::Type) }
+    # Given an AST node representing an RBI type (such as 'T::Array[String]'),  
+    # parses it into a generic type.
+    #
+    # @param [Parser::AST::Node] node
+    # @return [Parlour::Types::Type]
+    def parse_node_to_type(node)
+      case node.type
+      when :send
+        target, message, *args = *node
+
+        # Special case: is this a generic type instantiation?
+        if message == :[]
+          names = constant_names(target)
+          known_single_element_collections = [:Array, :Set, :Range, :Enumerator, :Enumerable]
+
+          if names.length == 2 && names[0] == :T && 
+            known_single_element_collections.include?(names[1])
+            
+            parse_err "no type in T::#{names[1]}[...]", node if args.nil? || args.empty?
+            parse_err "too many types in T::#{names[1]}[...]", node unless args.length == 1
+            return T.must(Types.const_get(T.must(names[1]))).new(parse_node_to_type(T.must(args.first)))
+          elsif names.length == 2 && names == [:T, :Hash]
+            parse_err "not enough types in T::Hash[...]", node if args.nil? || args.length < 2
+            parse_err "too many types in T::Hash[...]", node unless args.length == 2
+            return Types::Hash.new(
+              parse_node_to_type(args[0]), parse_node_to_type(args[1])
+            )
+          else
+            # TODO
+            warning "user-defined generic types not implemented, treating #{names.last} as untyped", node
+            return Types::Untyped.new
+          end
+        end
+
+        # Special case: is this a proc?
+        # This parsing is pretty simplified, but you'd also have to be doing
+        # something pretty cursed with procs to break this
+        # This checks for (send (send (send (const nil :T) :proc) ...) ...)
+        # That's the right amount of nesting for T.proc.params(...).returns(...)
+        if node.to_a[0].type == :send && 
+          node.to_a[0].to_a[0].type == :send &&
+          node.to_a[0].to_a[0].to_a[1] == :proc &&
+          node.to_a[0].to_a[0].to_a[0].type == :const &&
+          node.to_a[0].to_a[0].to_a[0].to_a == [nil, :T] # yuck
+
+          # Get parameters
+          params_send = node.to_a[0]
+          parse_err "expected 'params' to follow 'T.proc'", node unless params_send.to_a[1] == :params
+          parse_err "expected 'params' to have kwargs", node unless params_send.to_a[2].type == :hash
+
+          parameters = params_send.to_a[2].to_a.map do |pair|
+            name, value = *pair
+            parse_err "expected 'params' name to be symbol", node unless name.type == :sym
+            name = name.to_a[0].to_s
+            value = parse_node_to_type(value)
+
+            RbiGenerator::Parameter.new(name, type: value)
+          end
+
+          # Get return value
+          if node.to_a[1] == :void
+            return_type = nil
+          else
+            _, call, *args = *node
+            parse_err 'expected .returns or .void', node unless call == :returns
+            parse_err 'no argument to .returns', node if args.nil? || args.empty?
+            parse_err 'too many arguments to .returns', node unless args.length == 1
+            return_type = parse_node_to_type(T.must(args.first))
+          end
+
+          return Types::Proc.new(parameters, return_type)
+        end
+
+        # The other options for a valid call are all "T.something" methods
+        parse_err "unexpected call #{node_to_s(node).inspect} in type", node \
+          unless target.type == :const && target.to_a == [nil, :T]
+            
+        case message
+        when :nilable
+          parse_err 'no argument to T.nilable', node if args.nil? || args.empty?
+          parse_err 'too many arguments to T.nilable', node unless args.length == 1
+          Types::Nilable.new(parse_node_to_type(T.must(args.first)))
+        when :any
+          Types::Union.new((args || []).map { |x| parse_node_to_type(T.must(x)) })
+        when :all
+          Types::Intersection.new((args || []).map { |x| parse_node_to_type(T.must(x)) })
+        when :let
+          # Not really allowed in a type signature, but handy for generalizing
+          # constant types
+          parse_err 'not enough argument to T.let', node if args.nil? || args.length < 2
+          parse_err 'too many arguments to T.nilable', node unless args.length == 2
+          parse_node_to_type(args[1])
+        when :type_parameter
+          parse_err 'no argument to T.type_parameter', node if args.nil? || args.empty?
+          parse_err 'too many arguments to T.type_parameter', node unless args.length == 1
+          parse_err 'expected T.type_parameter to be passed a symbol', node unless T.must(args.first).type == :sym
+          Types::Raw.new(T.must(args.first.to_a[0].to_s))
+        when :class_of
+          parse_err 'no argument to T.class_of', node if args.nil? || args.empty?
+          parse_err 'too many arguments to T.class_of', node unless args.length == 1
+          Types::Class.new(parse_node_to_type(args[0]))
+        when :untyped
+          parse_err 'T.untyped does not accept arguments', node if !args.nil? && !args.empty?
+          Types::Untyped.new
+        else
+          warning "unknown method T.#{message}, treating as untyped", node
+          Types::Untyped.new
+        end 
+      when :const
+        # Special case: T::Boolean
+        if constant_names(node) == [:T, :Boolean]
+          return Types::Boolean.new
+        end
+
+        # Otherwise, just a plain old constant
+        Types::Raw.new(constant_names(node).join('::'))
+      when :array
+        # Tuple
+        Types::Tuple.new(node.to_a.map { |x| parse_node_to_type(T.must(x)) })
+      when :hash
+        # Shape/record
+        keys_to_types = node.to_a.map do |pair|
+          key, value = *pair
+          parse_err "all shape keys must be symbols", node unless key.type == :sym
+          [key.to_a[0], parse_node_to_type(value)]
+        end.to_h
+
+        Types::Record.new(keys_to_types)
+      else
+        parse_err "unable to parse type #{node_to_s(node).inspect}", node
+      end
+    end
+
     protected
 
+    sig { params(msg: String, node: Parser::AST::Node).void }
+    def warning(msg, node)
+      return if $VERBOSE.nil?
+
+      print Rainbow("Parlour warning: ").yellow.dark.bold
+      print Rainbow("Type generalization: ").magenta.bright.bold
+      puts msg
+      print Rainbow("      └ at code: ").blue.bright.bold
+      puts node_to_s(node)
+    end
+
     sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) }
     # Given a node representing a simple chain of constants (such as A or
     # A::B::C), converts that node into an array of the constant names which
     # are accessed. For example, A::B::C would become [:A, :B, :C].
     #
-    # @param [Parser::AST::Node, nil] node The node to convert. This must 
+    # @param [Parser::AST::Node, nil] node The node to convert. This must
     #   consist only of nested (:const) nodes.
     # @return [Array<Symbol>] The chain of constant names.
     def constant_names(node)
@@ -497,6 +876,24 @@ module Parlour
         node.to_a[0].to_a[1] == :sig
     end
 
+    sig { params(path: NodePath).returns(T::Boolean) }
+    # Given a path, returns a boolean indicating whether the previous sibling
+    # represents a call to "sig" with a block.
+    #
+    # @param [NodePath] path The path to the namespace definition.
+    # @return [Boolean] True if that node represents a "sig" call, false
+    #   otherwise.
+    def previous_sibling_sig_node?(path)
+      previous_sibling = path.sibling(-1)
+      previous_node = previous_sibling.traverse(ast)
+      sig_node?(previous_node)
+    rescue IndexError, ArgumentError, TypeError
+      # `sibling` call could raise IndexError or ArgumentError if reaching into negative indices
+      # `traverse` call could raise TypeError if path doesn't return Parser::AST::Node
+
+      false
+    end
+
     sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
     # Given an AST node, returns the source code from which it was constructed.
     # If the given AST node is nil, this returns nil.
@@ -524,13 +921,13 @@ module Parlour
     def body_has_modifier?(node, modifier)
       return false unless node
 
-      (node.type == :send && node.to_a == [nil, modifier]) || 
+      (node.type == :send && node.to_a == [nil, modifier]) ||
         (node.type == :begin &&
           node.to_a.any? { |c| c.type == :send && c.to_a == [nil, modifier] })
     end
 
     sig { params(node: Parser::AST::Node).returns([T::Array[String], T::Array[String]]) }
-    # Given an AST node representing the body of a class or module, returns two 
+    # Given an AST node representing the body of a class or module, returns two
     # arrays of the includes and extends contained within the body.
     #
     # @param [Parser::AST::Node] node The body of the namespace.
@@ -568,7 +965,7 @@ module Parlour
       raise ParseError.new(buffer, range), desc
     end
 
-    sig do 
+    sig do
       type_parameters(:A, :B)
         .params(
           a: T::Array[T.type_parameter(:A)],
@@ -580,7 +977,7 @@ module Parlour
     end
     # Given two arrays and functions to get a key for each item in the two
     # arrays, joins the two arrays into one array of pairs by that key.
-    # 
+    #
     # The arrays should both be the same length, and the key functions should
     # never return duplicate keys for two different items.
     #
@@ -588,7 +985,7 @@ module Parlour
     # @param [A -> Any] fa A function to obtain a key for any element in the
     #   first array.
     # @param [Array<B>] b The second array.
-    # @param [B -> Any] fb A function to obtain a key for any element in the 
+    # @param [B -> Any] fb A function to obtain a key for any element in the
     #   second array.
     # @return [Array<(A, B)>] An array of pairs, where the left of the pair is
     #   an element from A and the right is the element from B with the
@@ -606,4 +1003,4 @@ module Parlour
       end
     end
   end
-end
+end