parlour 3.0.0 → 5.0.0.beta.3

data/lib/parlour.rb

@@ -9,12 +9,17 @@ require 'parlour/kernel_hack'
 
 require 'parlour/plugin'
 
+require 'parlour/types'
+
+require 'parlour/options'
+require 'parlour/typed_object'
+require 'parlour/generator'
 require 'parlour/rbi_generator/parameter'
 require 'parlour/rbi_generator/rbi_object'
+require 'parlour/rbi_generator/type_alias'
 require 'parlour/rbi_generator/method'
 require 'parlour/rbi_generator/attribute'
 require 'parlour/rbi_generator/arbitrary'
-require 'parlour/rbi_generator/options'
 require 'parlour/rbi_generator/include'
 require 'parlour/rbi_generator/extend'
 require 'parlour/rbi_generator/constant'
@@ -27,6 +32,27 @@ require 'parlour/rbi_generator/struct_class_namespace'
 require 'parlour/rbi_generator'
 require 'parlour/detached_rbi_generator'
 
+require 'parlour/rbs_generator/rbs_object'
+require 'parlour/rbs_generator/type_alias'
+require 'parlour/rbs_generator/namespace'
+require 'parlour/rbs_generator/method'
+require 'parlour/rbs_generator/arbitrary'
+require 'parlour/rbs_generator/attribute'
+require 'parlour/rbs_generator/block'
+require 'parlour/rbs_generator/class_namespace'
+require 'parlour/rbs_generator/constant'
+require 'parlour/rbs_generator/extend'
+require 'parlour/rbs_generator/include'
+require 'parlour/rbs_generator/method_signature'
+require 'parlour/rbs_generator/module_namespace'
+require 'parlour/rbs_generator/interface_namespace'
+require 'parlour/rbs_generator/parameter'
+require 'parlour/rbs_generator'
+require 'parlour/detached_rbs_generator'
+
+require 'parlour/conversion/converter'
+require 'parlour/conversion/rbi_to_rbs'
+
 require 'parlour/conflict_resolver'
 
 require 'parlour/parse_error'

data/lib/parlour/conflict_resolver.rb

@@ -13,7 +13,7 @@ module Parlour
         resolver: T.proc.params(
           desc: String,
           choices: T::Array[RbiGenerator::RbiObject]
-        ).returns(RbiGenerator::RbiObject)
+        ).returns(T.nilable(RbiGenerator::RbiObject))
       ).void
     end
     # Given a namespace, attempts to automatically resolve conflicts in the
@@ -23,13 +23,13 @@ module Parlour
     # All children of the given namespace which are also namespaces are
     # processed recursively, so passing {RbiGenerator#root} will eliminate all
     # conflicts in the entire object tree.
-    # 
+    #
     # If automatic resolution is not possible, the block passed to this method
     # is invoked and passed two arguments: a message on what the conflict is,
     # and an array of candidate objects. The block should return one of these
     # candidate objects, which will be kept, and all other definitions are
     # deleted. Alternatively, the block may return nil, which will delete all
-    # definitions. The block may be invoked many times from one call to 
+    # definitions. The block may be invoked many times from one call to
     # {resolve_conflicts}, one for each unresolvable conflict.
     #
     # @param namespace [RbiGenerator::Namespace] The starting namespace to
@@ -52,14 +52,14 @@ module Parlour
           child.name
         end
       end
-      
+
       grouped_by_name_children.each do |name, children|
         Debugging.debug_puts(self, Debugging::Tree.begin("Checking children named #{name}..."))
 
         if children.length > 1
           Debugging.debug_puts(self, Debugging::Tree.here("Possible conflict between #{children.length} objects"))
 
-          # Special case: do we have two methods, one of which is a class method 
+          # Special case: do we have two methods, one of which is a class method
           # and the other isn't? If so, do nothing - this is fine
           if children.length == 2 &&
             children.all? { |c| c.is_a?(RbiGenerator::Method) } &&
@@ -78,12 +78,13 @@ module Parlour
                 c.is_a?(RbiGenerator::Include) || c.is_a?(RbiGenerator::Extend)
               end
             end
-            
+            deduplicate_mixins_of_name(namespace, name)
+
             Debugging.debug_puts(self, Debugging::Tree.end("Includes/extends do not conflict with namespaces; no resolution required"))
             next
           end
 
-          # Special case: do we have two attributes, one of which is a class 
+          # Special case: do we have two attributes, one of which is a class
           # attribute and the other isn't? If so, do nothing - this is fine
           if children.length == 2 &&
             children.all? { |c| c.is_a?(RbiGenerator::Attribute) } &&
@@ -93,13 +94,13 @@ module Parlour
             next
           end
 
-          # Special case: are they all clearly equal? If so, remove all but one
+          # Optimization for Special case: are they all clearly equal? If so, remove all but one
           if all_eql?(children)
             Debugging.debug_puts(self, Debugging::Tree.end("All children are identical"))
 
             # All of the children are the same, so this deletes all of them
             namespace.children.delete(T.must(children.first))
-          
+
             # Re-add one child
             namespace.children << T.must(children.first)
             next
@@ -239,5 +240,26 @@ module Parlour
     def all_eql?(arr)
       arr.each_cons(2).all? { |x, y| x == y }
     end
+
+    sig { params(namespace: RbiGenerator::Namespace, name: T.nilable(String)).void }
+    # Given a namespace and a child name, removes all duplicate children that are mixins
+    # and that have the given name, except the first found instance.
+    #
+    # @param namespace [RbiGenerator::Namespace] The namespace to deduplicate mixins in.
+    # @param name [String] The name of the mixin modules to deduplicate.
+    # @return [void]
+    def deduplicate_mixins_of_name(namespace, name)
+      found_map = {}
+      namespace.children.delete_if do |x|
+        # ignore children whose names don't match
+        next unless x.name == name
+        # ignore children that are not mixins
+        next unless x.is_a?(RbiGenerator::Include) || x.is_a?(RbiGenerator::Extend)
+
+        delete = found_map.key?(x.class)
+        found_map[x.class] = true
+        delete
+      end
+    end
   end
 end

data/lib/parlour/conversion/converter.rb

@@ -0,0 +1,34 @@
+# typed: true
+require 'rainbow'
+
+module Parlour
+  module Conversion
+    # An abstract class which converts between the node trees of two type
+    # systems.
+    class Converter
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      def initialize
+        @warnings = []
+      end
+
+      sig { returns(T::Array[[String, TypedObject]]) }
+      attr_reader :warnings
+
+      sig { params(msg: String, node: RbiGenerator::RbiObject).void }
+      def add_warning(msg, node)
+        warnings << [msg, node]
+
+        return if $VERBOSE.nil?
+        class_name = T.must(self.class.name).split('::').last
+        print Rainbow("Parlour warning: ").yellow.dark.bold
+        print Rainbow("#{class_name}: ").magenta.bright.bold
+        puts msg
+        print Rainbow("    └ at object: ").blue.bright.bold
+        puts node.describe
+      end
+    end
+  end
+end

data/lib/parlour/conversion/rbi_to_rbs.rb

@@ -0,0 +1,223 @@
+# typed: true
+module Parlour
+  module Conversion
+    # Converts RBI types to RBS types.
+    class RbiToRbs < Converter
+      extend T::Sig
+
+      sig { params(rbs_gen: RbsGenerator).void }
+      def initialize(rbs_gen)
+        super()
+        @rbs_gen = rbs_gen
+      end
+
+      sig { returns(RbsGenerator) }
+      attr_reader :rbs_gen
+
+      sig { params(from: RbiGenerator::Namespace, to: RbsGenerator::Namespace).void }
+      def convert_all(from, to)
+        from.children.each do |child|
+          convert_object(child, to)
+        end        
+      end
+
+      sig do
+        params(
+          node: RbiGenerator::RbiObject,
+          new_parent: RbsGenerator::Namespace,
+        ).void
+      end
+      def convert_object(node, new_parent)        
+        case node
+        when RbiGenerator::StructClassNamespace
+          add_warning 'performing a one-way conversion of an RBI struct to RBS', node
+
+          klass = new_parent.create_class(node.name)
+          klass.add_comments(node.comments)
+
+          # Create a constructor
+          klass.create_method('initialize', [
+            RbsGenerator::MethodSignature.new(
+              node.props.map do |prop|
+                RbsGenerator::Parameter.new(
+                  "#{prop.name}:",
+                  type: prop.type,
+                  required: !prop.optional,
+                )
+              end,
+              nil,
+            )
+          ])
+
+          # Make each prop a getter (and setter, if not immutable) attribute
+          node.props.each do |prop|
+            klass.create_attribute(
+              prop.name,
+              kind: prop.immutable ? :reader : :accessor,
+              type: prop.type,
+            )
+          end
+
+          klass 
+
+        when RbiGenerator::EnumClassNamespace
+          add_warning 'performing a one-way conversion of an RBI enum to RBS', node
+
+          klass = new_parent.create_class(node.name)
+          klass.add_comments(node.comments)
+
+          # Define .values
+          klass.create_method('values', [
+            RbsGenerator::MethodSignature.new([], Types::Array.new(node.name))
+          ], class_method: true)
+
+          # Define each enum variant
+          node.enums.each do |variant|
+            # We don't care about any extra value
+            variant = variant[0] if Array === variant
+
+            klass.create_constant(variant, type: node.name)
+          end
+
+          klass
+
+        when RbiGenerator::Arbitrary
+          add_warning 'converting type of Arbitrary is likely to cause syntax errors; doing it anyway', node
+          new_parent.create_arbitrary(
+            code: node.code,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::Attribute
+          if node.class_attribute
+            add_warning 'RBS does not support class attributes; dropping', node
+            return
+          end
+          new_parent.create_attribute(
+            node.name,
+            kind: node.kind,
+            type: node.type,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::ClassNamespace
+          if node.abstract
+            add_warning 'RBS does not support abstract classes', node
+          end
+          klass = new_parent.create_class(
+            node.name,
+            superclass: node.superclass
+          )
+          klass.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, klass)
+          end
+
+        when RbiGenerator::Constant
+          if node.eigen_constant
+            add_warning 'RBS does not support constants on eigenclasses; dropping', node
+            return
+          end
+          new_parent.create_constant(
+            node.name,
+            type: node.value,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::Extend
+          new_parent.create_extend(node.name).add_comments(node.comments)
+
+        when RbiGenerator::Include
+          new_parent.create_include(node.name).add_comments(node.comments)
+
+        when RbiGenerator::Method
+          # Convert parameters
+          parameters = node.parameters
+            .reject { |param| param.kind == :block }
+            .map do |param|
+              RbsGenerator::Parameter.new(
+                param.name,
+                type: param.type,
+                required: param.default.nil?
+              )
+            end
+
+          # Find block if there is one
+          block_param = node.parameters.find { |param| param.kind == :block }
+          if block_param
+            if String === block_param.type
+              add_warning "block must have a Types::Type for conversion; dropping block", node
+              block = nil
+            else
+              # A nilable proc is an optional block
+              block_param_type = block_param.type
+              if Types::Nilable === block_param_type && Types::Proc === block_param_type.type
+                t = T.cast(block_param_type.type, Types::Proc)
+                required = false
+                block = RbsGenerator::Block.new(t, required)
+              elsif Types::Proc === block_param_type
+                t = block_param_type
+                required = true
+                block = RbsGenerator::Block.new(t, required)
+              elsif Types::Untyped === block_param_type
+                # Consider there to be a block of unknown types
+                block = RbsGenerator::Block.new(
+                  Types::Proc.new(
+                    [
+                      Types::Proc::Parameter.new('*args', Types::Untyped.new),
+                      Types::Proc::Parameter.new('**kwargs', Types::Untyped.new),
+                    ],
+                    Types::Untyped.new,
+                  ),
+                  false,
+                )
+              else
+                add_warning 'block type must be a Types::Proc (or nilable one); dropping block', node
+              end
+            end
+          else
+            block = nil
+          end
+
+          new_parent.create_method(
+            node.name,
+            [
+              RbsGenerator::MethodSignature.new(
+                parameters,
+                node.return_type,
+                block: block,
+                type_parameters: node.type_parameters,
+              )
+            ],
+            class_method: node.class_method,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::ModuleNamespace
+          if node.interface
+            rbs_node = new_parent.create_interface(
+              node.name,
+            )
+          else
+            rbs_node = new_parent.create_module(
+              node.name,
+            )
+          end
+          rbs_node.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, rbs_node)
+          end
+
+        when RbiGenerator::Namespace
+          add_warning 'unspecialized namespaces are not supposed to be in the tree; you may run into issues', node
+          namespace = RbsGenerator::Namespace.new(rbs_gen)
+          namespace.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, namespace)
+          end
+          new_parent.children << namespace
+
+        else
+          raise "missing conversion for #{node.describe}"
+          # TODO: stick a T.absurd here
+        end
+      end
+    end
+  end
+end

data/lib/parlour/detached_rbi_generator.rb

@@ -6,17 +6,12 @@ module Parlour
     def detached!
       raise "cannot call methods on a detached RBI generator"
     end
-  
+
     sig { override.returns(Options) }
     def options
       detached!
     end
 
-    sig { override.returns(Namespace) }
-    def root
-      detached!
-    end
-
     sig { override.returns(T.nilable(Plugin)) }
     def current_plugin
       nil

data/lib/parlour/detached_rbs_generator.rb

@@ -0,0 +1,25 @@
+# typed: true
+
+module Parlour
+  class DetachedRbsGenerator < RbsGenerator
+    sig { returns(T.untyped) }
+    def detached!
+      raise "cannot call methods on a detached RBS generator"
+    end
+
+    sig { override.returns(Options) }
+    def options
+      detached!
+    end
+
+    sig { override.returns(T.nilable(Plugin)) }
+    def current_plugin
+      nil
+    end
+
+    sig { override.returns(String) }
+    def rbs
+      detached!
+    end
+  end
+end