steep 0.36.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5203340eb3b3534da5f1071cc497bbe7a481553e909088277c83dbfe5e5c0bbc
-  data.tar.gz: 11863c0ea9b692de6fba552ec01645525240c025c598235f9b3bf88e35571ed5
+  metadata.gz: f3d9186b6988081611f8bf060700ad97eb408ab605ab11ab32b717b9a0e9b8b9
+  data.tar.gz: 6f308f7bd551472237d5857614b765468782290733514793b2dfe35a3ac232cf
 SHA512:
-  metadata.gz: 9897fecb7ca5b60da9eeb236e5f06af1a9b2fa2a2df2bd87d07f7a496f0f05b988b30db2e294797304c6d7f0e8fe478cdc1d41049cbaf2e56c45108444b2c721
-  data.tar.gz: fa2dca2cd37d74e39878ab3da7a5453a714f50e921fcd1c0e75054bf083a11003cb5799f4f92531a10bce6074dce3cce88c90daeb214b9fb45d7f5612e294fb3
+  metadata.gz: 1fee308a7783a6e54c974c71c78189492c0f557528bccb0da530927cfdb4e4a16f4ff6cd2ec9f8c3292dd9839bb1637f68fd3aff9da0fef6783e3f4b5d838984
+  data.tar.gz: 7cd72caf879d339e5fec0bed219957befd40d5dc2466b345435f4b523c8028a9264404b1d9c695c11ca638b8e6bbeb1d1ad8f600367cd87bf9b3c4fade99eeaa

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.37.0 (2020-12-06)
+
+* Update to RBS 0.20.0 with _singleton attribute_ syntax and _proc types with blocks_. ([#264](https://github.com/soutaro/steep/pull/264))
+
 ## 0.36.0 (2020-11-16)
 
 * Flow-sensitive typing improvements with `||` and `&&` ([#260](https://github.com/soutaro/steep/pull/260))

data/lib/steep.rb

@@ -42,6 +42,8 @@ require "steep/ast/annotation/collection"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
+require "steep/interface/function"
+require "steep/interface/block"
 require "steep/interface/method_type"
 require "steep/interface/substitution"
 require "steep/interface/interface"

data/lib/steep/ast/types/factory.rb

@@ -75,9 +75,23 @@ module Steep
             end
             Record.new(elements: elements, location: nil)
           when RBS::Types::Proc
-            params = params(type.type)
-            return_type = type(type.type.return_type)
-            Proc.new(params: params, return_type: return_type, location: nil)
+            func = Interface::Function.new(
+              params: params(type.type),
+              return_type: type(type.type.return_type),
+              location: type.location
+            )
+            block = if type.block
+                      Interface::Block.new(
+                        type: Interface::Function.new(
+                          params: params(type.block.type),
+                          return_type: type(type.block.type.return_type),
+                          location: type.location
+                        ),
+                        optional: !type.block.required
+                      )
+                    end
+
+            Proc.new(type: func, block: block)
           else
             raise "Unexpected type given: #{type}"
           end
@@ -145,8 +159,15 @@ module Steep
             end
             RBS::Types::Record.new(fields: fields, location: nil)
           when Proc
+            block = if type.block
+                      RBS::Types::Block.new(
+                        type: function_1(type.block.type),
+                        required: !type.block.optional?
+                      )
+                    end
             RBS::Types::Proc.new(
-              type: function_1(type.params, type.return_type),
+              type: function_1(type.type),
+              block: block,
               location: nil
             )
           when Logic::Base
@@ -156,7 +177,10 @@ module Steep
           end
         end
 
-        def function_1(params, return_type)
+        def function_1(func)
+          params = func.params
+          return_type = func.return_type
+
           RBS::Types::Function.new(
             required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
@@ -170,7 +194,7 @@ module Steep
         end
 
         def params(type)
-          Interface::Params.new(
+          Interface::Function::Params.new(
             required: type.required_positionals.map {|param| type(param.type) },
             optional: type.optional_positionals.map {|param| type(param.type) },
             rest: type.rest_positionals&.yield_self {|param| type(param.type) },
@@ -202,13 +226,19 @@ module Steep
 
           type = Interface::MethodType.new(
             type_params: type_params,
-            return_type: type(method_type.type.return_type).subst(subst),
-            params: params(method_type.type).subst(subst),
+            type: Interface::Function.new(
+              params: params(method_type.type).subst(subst),
+              return_type: type(method_type.type.return_type).subst(subst),
+              location: method_type.location
+            ),
             block: method_type.block&.yield_self do |block|
               Interface::Block.new(
                 optional: !block.required,
-                type: Proc.new(params: params(block.type).subst(subst),
-                               return_type: type(block.type.return_type).subst(subst), location: nil)
+                type: Interface::Function.new(
+                  params: params(block.type).subst(subst),
+                  return_type: type(block.type.return_type).subst(subst),
+                  location: nil
+                )
               )
             end,
             method_decls: method_decls
@@ -242,12 +272,12 @@ module Steep
 
           type = RBS::MethodType.new(
             type_params: type_params,
-            type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
+            type: function_1(method_type.type.subst(subst)),
             block: method_type.block&.yield_self do |block|
               block_type = block.type.subst(subst)
 
-              RBS::MethodType::Block.new(
-                type: function_1(block_type.params, block_type.return_type),
+              RBS::Types::Block.new(
+                type: function_1(block_type),
                 required: !block.optional
               )
             end,
@@ -354,7 +384,9 @@ module Steep
             when :is_a?, :kind_of?, :instance_of?
               if defined_in == RBS::BuiltinNames::Object.name && member.instance?
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -363,7 +395,9 @@ module Steep
               when RBS::BuiltinNames::Object.name,
                 NilClassName
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -373,7 +407,9 @@ module Steep
                 RBS::BuiltinNames::TrueClass.name,
                 RBS::BuiltinNames::FalseClass.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -381,7 +417,9 @@ module Steep
               case defined_in
               when RBS::BuiltinNames::Module.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
             end
@@ -572,14 +610,17 @@ module Steep
                     method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index)],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
                         method_decls: Set[]
                       )
                     } + aref.method_types
@@ -591,14 +632,17 @@ module Steep
                     method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
                         method_decls: Set[]
                       )
                     } + update.method_types
@@ -610,9 +654,12 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types[0] || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types[0] || AST::Builtin.nil_type,
                         method_decls: Set[]
                       )
                     ]
@@ -624,9 +671,12 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types.last || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types.last || AST::Builtin.nil_type,
                         method_decls: Set[]
                       )
                     ]
@@ -651,14 +701,17 @@ module Steep
 
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [key_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: value_type,
                         method_decls: Set[]
                       )
                     } + ref.method_types
@@ -671,14 +724,16 @@ module Steep
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [key_type, value_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type, value_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil),
                         block: nil,
-                        return_type: value_type,
                         method_decls: Set[]
                       )
                     } + update.method_types
@@ -691,14 +746,18 @@ module Steep
             interface(Builtin::Proc.instance_type, private: private, self_type: self_type).tap do |interface|
               method_type = Interface::MethodType.new(
                 type_params: [],
-                params: type.params,
-                return_type: type.return_type,
-                block: nil,
+                type: type.type,
+                block: type.block,
                 method_decls: Set[]
               )
 
-              interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])
               interface.methods[:call] = Interface::Interface::Entry.new(method_types: [method_type])
+
+              if type.block_required?
+                interface.methods.delete(:[])
+              else
+                interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type.with(block: nil)])
+              end
             end
 
           when Logic::Base

data/lib/steep/ast/types/proc.rb

@@ -3,68 +3,76 @@ module Steep
     module Types
       class Proc
         attr_reader :location
-        attr_reader :params
-        attr_reader :return_type
+        attr_reader :type
+        attr_reader :block
 
-        def initialize(params:, return_type:, location: nil)
+        def initialize(type:, block:, location: type.location)
+          @type = type
+          @block = block
           @location = location
-          @params = params
-          @return_type = return_type
         end
 
         def ==(other)
-          other.is_a?(self.class) &&
-            other.params == params &&
-            other.return_type == return_type
+          other.is_a?(self.class) && other.type == type && other.block == block
         end
 
         def hash
-          self.class.hash && params.hash && return_type.hash
+          self.class.hash ^ type.hash ^ block.hash
         end
 
         alias eql? ==
 
         def subst(s)
           self.class.new(
-            params: params.subst(s),
-            return_type: return_type.subst(s),
+            type: type.subst(s),
+            block: block&.subst(s),
             location: location
           )
         end
 
         def to_s
-          "^#{params} -> #{return_type}"
+          if block
+            "^#{type.params} #{block} -> #{type.return_type}"
+          else
+            "^#{type.params} -> #{type.return_type}"
+          end
         end
 
         def free_variables()
-          @fvs ||= Set.new.tap do |set|
-            set.merge(params.free_variables)
-            set.merge(return_type.free_variables)
+          @fvs ||= Set[].tap do |fvs|
+            fvs.merge(type.free_variables)
+            fvs.merge(block.free_variables) if block
           end
         end
 
         def level
-          children = params.each_type.to_a + [return_type]
+          children = type.params.each_type.to_a + [type.return_type]
+          if block
+            children.push(*block.type.params.each_type.to_a)
+            children.push(block.type.return_type)
+          end
           [0] + level_of_children(children)
         end
 
         def closed?
-          params.closed? && return_type.closed?
+          type.closed? && (block.nil? || block.closed?)
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location, params: params, return_type: return_type)
+          self.class.new(location: new_location, block: block, type: type)
         end
 
         def map_type(&block)
           self.class.new(
-            params: params.map_type(&block),
-            return_type: yield(return_type),
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
             location: location
           )
         end
 
         def one_arg?
+          params = type.params
+
           params.required.size == 1 &&
             params.optional.empty? &&
             !params.rest &&
@@ -78,6 +86,10 @@ module Steep
                              args: [],
                              location: location)
         end
+
+        def block_required?
+          block && !block.optional?
+        end
       end
     end
   end

data/lib/steep/interface/block.rb

@@ -0,0 +1,79 @@
+module Steep
+  module Interface
+    class Block
+      attr_reader :type
+      attr_reader :optional
+
+      def initialize(type:, optional:)
+        @type = type
+        @optional = optional
+      end
+
+      def optional?
+        @optional
+      end
+
+      def to_optional
+        self.class.new(
+          type: type,
+          optional: true
+        )
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.type == type && other.optional == optional
+      end
+
+      alias eql? ==
+
+      def hash
+        type.hash ^ optional.hash
+      end
+
+      def closed?
+        type.closed?
+      end
+
+      def subst(s)
+        ty = type.subst(s)
+        if ty == type
+          self
+        else
+          self.class.new(
+            type: ty,
+            optional: optional
+          )
+        end
+      end
+
+      def free_variables()
+        @fvs ||= type.free_variables
+      end
+
+      def to_s
+        "#{optional? ? "?" : ""}{ #{type.params} -> #{type.return_type} }"
+      end
+
+      def map_type(&block)
+        self.class.new(
+          type: type.map_type(&block),
+          optional: optional
+        )
+      end
+
+      def +(other)
+        optional = self.optional? || other.optional?
+        type = Function.new(
+          params: self.type.params + other.type.params,
+          return_type: AST::Types::Union.build(types: [self.type.return_type, other.type.return_type]),
+          location: nil
+        )
+
+        self.class.new(
+          type: type,
+          optional: optional
+        )
+      end
+    end
+  end
+end