parlour 5.0.0.beta.4 → 5.0.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28a746eeb5c6322d0dfbfc53336bde66a65a35462f8e7685098aadd8720d3ade
-  data.tar.gz: 5cd5e9fe8cd248e1b7685134b3116f04c28e481d30ed6ac01b77b6f82aa7236b
+  metadata.gz: 954aae86deb14e48d6fd3e1491bfc90e511e06f2339697b41f06bb137f93ae84
+  data.tar.gz: 5720e034546be195412725a2c5cb58dc14325485eb9720491db4b29b49e83026
 SHA512:
-  metadata.gz: 51d1cdde17b3d84ae927343e7627efc2ef832440907b8f3ae40ec3cf20edcd20a8f7f76f3991933251a7542ccc7b6ac1269a98a268603e34eaaf043322e05625
-  data.tar.gz: d84ae4f6260e82de62dafdc67a7715c9cd74f01a68bbce8f5e89d0aa1f00509bd4a5230ec0fa7c850898f57936e29aee07c8f607935dbc1c784f4212ff709246
+  metadata.gz: c2ff5915c768f8fa5432b0fcb7f0ae89fb3385c6a500ab9f46dedab301f44084620203219e7bac044b48ec2659b9ca729b2d5f2ce0b15e6222c9d3ddec4ca2a2
+  data.tar.gz: e0edbaf4e923f7b80956072ebc82e1ef1075e6791e8ef7e147da0b533709b62e421e786a0dbd36b8bd11473c59b5f302972deb91d7590d4acae69caebcac1887

data/CHANGELOG.md

@@ -3,6 +3,10 @@ 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.beta.5] - 2020-10-03
+### Added
+- Added `Types::Generic` for user-defined generic types
+
 ## [5.0.0.beta.4] - 2020-09-22
 ### Added
 - Added support for parsing type aliases from RBI

data/lib/parlour/type_parser.rb

@@ -721,7 +721,7 @@ module Parlour
     end
 
     sig { params(node: Parser::AST::Node).returns(Types::Type) }
-    # Given an AST node representing an RBI type (such as 'T::Array[String]'),  
+    # Given an AST node representing an RBI type (such as 'T::Array[String]'),
     # parses it into a generic type.
     #
     # @param [Parser::AST::Node] node
@@ -736,9 +736,9 @@ module Parlour
           names = constant_names(target)
           known_single_element_collections = [:Array, :Set, :Range, :Enumerator, :Enumerable]
 
-          if names.length == 2 && names[0] == :T && 
+          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)))
@@ -749,9 +749,17 @@ module Parlour
               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
+            type = names.join('::')
+            if args.nil?
+              parse_err(
+                "user defined generic '#{type}' requires at least one type parameter",
+                node
+              )
+            end
+            return Types::Generic.new(
+              type,
+              args.map { |arg| parse_node_to_type(arg) }
+            )
           end
         end
 
@@ -760,7 +768,7 @@ module Parlour
         # 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 && 
+        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 &&
@@ -797,7 +805,7 @@ module Parlour
         # 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?
@@ -828,7 +836,7 @@ module Parlour
         else
           warning "unknown method T.#{message}, treating as untyped", node
           Types::Untyped.new
-        end 
+        end
       when :const
         # Special case: T::Boolean
         if constant_names(node) == [:T, :Boolean]

data/lib/parlour/types.rb

@@ -196,6 +196,45 @@ module Parlour
       end
     end
 
+    # A user-defined generic class with an arbitrary number of type
+    # parameters. This class assumes at least one type_param is
+    # provided, otherwise output will have empty type param lists.
+    class Generic < Type
+      sig { params(type: TypeLike, type_params: T::Array[TypeLike]).void }
+      def initialize(type, type_params)
+        @type = to_type(type)
+        @type_params = type_params.map { |p| to_type(p) }
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        self.class === other &&
+          type == other.type &&
+          type_params == other.type_params
+      end
+
+      sig { returns(Type) }
+      attr_reader :type
+
+      sig { returns(T::Array[Type]) }
+      attr_reader :type_params
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "#{type.generate_rbi}[#{type_params.map(&:generate_rbi).join(', ')}]"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "#{type.generate_rbs}[#{type_params.map(&:generate_rbs).join(', ')}]"
+      end
+
+      sig { override.returns(String) }
+      def describe
+        "#{type.describe}<#{type_params.map(&:describe).join(', ')}>"
+      end
+    end
+
     class SingleElementCollection < Type
       abstract!
 
@@ -436,9 +475,9 @@ module Parlour
       def describe
         "self"
       end
-    end    
+    end
 
-    # The explicit lack of a type. 
+    # The explicit lack of a type.
     class Untyped < Type
       sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
@@ -487,9 +526,9 @@ module Parlour
         def ==(other)
           Parameter === other && name == other.name && type == other.type &&
             default == other.default
-        end  
+        end
       end
-      
+
       sig { params(parameters: T::Array[Parameter], return_type: T.nilable(TypeLike)).void }
       def initialize(parameters, return_type)
         @parameters = parameters
@@ -536,4 +575,4 @@ module Parlour
     end
   end
 end
-        
+

data/lib/parlour/version.rb

@@ -1,5 +1,5 @@
 # typed: strong
 module Parlour
   # The library version.
-  VERSION = '5.0.0.beta.4'
+  VERSION = '5.0.0.beta.5'
 end

data/rbi/parlour.rbi

@@ -427,6 +427,29 @@ module Parlour
       def describe; end
     end
 
+    class Generic < Type
+      sig { params(type: TypeLike, type_params: T::Array[TypeLike]).void }
+      def initialize(type, type_params); end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other); end
+
+      sig { returns(Type) }
+      attr_reader :type
+
+      sig { returns(T::Array[Type]) }
+      attr_reader :type_params
+
+      sig { override.returns(String) }
+      def generate_rbi; end
+
+      sig { override.returns(String) }
+      def generate_rbs; end
+
+      sig { override.returns(String) }
+      def describe; end
+    end
+
     class SingleElementCollection < Type
       abstract!
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta.4
+  version: 5.0.0.beta.5
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-22 00:00:00.000000000 Z
+date: 2020-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime