steep 0.4.0 → 0.5.0

data/lib/steep/interface/builder.rb

@@ -73,6 +73,12 @@ module Steep
             types: type.types.map {|ty| absolute_type(ty, current:current) },
             location: type.location
           )
+        when AST::Types::Proc
+          AST::Types::Proc.new(
+            params: type.params.map_type {|ty| absolute_type(ty, current: current) },
+            return_type: absolute_type(type.return_type, current: current),
+            location: type.location
+          )
         else
           type
         end
@@ -137,7 +143,7 @@ module Steep
         merge_ivars ivars, instantiated.ivars
       end
 
-      def add_method(type_name, method, methods:)
+      def add_method(type_name, method, methods:, extra_attributes: [])
         super_method = methods[method.name]
         new_method = Method.new(
           type_name: type_name,
@@ -146,7 +152,7 @@ module Steep
             method_type_to_method_type(method_type, current: type_name.name)
           end,
           super_method: super_method,
-          attributes: method.attributes
+          attributes: method.attributes + extra_attributes
         )
 
         methods[method.name] = if super_method&.include_in_chain?(new_method)
@@ -243,6 +249,17 @@ module Steep
           end
         end
 
+        signatures.find_extensions(sig.name).each do |ext|
+          ext.members.each do |member|
+            case member
+            when AST::Signature::Members::Method
+              if member.module_method?
+                add_method(type_name, member, methods: methods)
+              end
+            end
+          end
+        end
+
         unless constructor
           methods.delete(:new)
         end
@@ -261,6 +278,7 @@ module Steep
 
         supers = [sig.self_type].compact.map {|type| absolute_type(type, current: nil) }
         methods = {}
+        ivar_chains = {}
 
         module_instance = build(TypeName::Instance.new(name: ModuleName.parse("::Module")))
         instantiated = module_instance.instantiate(
@@ -277,14 +295,14 @@ module Steep
             merge_mixin(TypeName::Module.new(name: member.name),
                         member.args.map {|type| absolute_type(type, current: sig.name) },
                         methods: methods,
-                        ivars: {},
+                        ivars: ivar_chains,
                         supers: supers,
                         current: sig.name)
           when AST::Signature::Members::Extend
             merge_mixin(TypeName::Instance.new(name: member.name),
                         member.args.map {|type| absolute_type(type, current: sig.name) },
                         methods: methods,
-                        ivars: {},
+                        ivars: ivar_chains,
                         supers: supers,
                         current: sig.name)
           end
@@ -296,6 +314,22 @@ module Steep
             if member.module_method?
               add_method(type_name, member, methods: methods)
             end
+          when AST::Signature::Members::Ivar
+            merge_ivars(ivar_chains,
+                        { member.name => absolute_type(member.type, current: sig.name) })
+          when AST::Signature::Members::Attr
+            merge_attribute(sig, ivar_chains, methods, type_name, member)
+          end
+        end
+
+        signatures.find_extensions(sig.name).each do |ext|
+          ext.members.each do |member|
+            case member
+            when AST::Signature::Members::Method
+              if member.module_method?
+                add_method(type_name, member, methods: methods)
+              end
+            end
           end
         end
 
@@ -304,7 +338,7 @@ module Steep
           params: [],
           methods: methods,
           supers: supers,
-          ivar_chains: {}
+          ivar_chains: ivar_chains
         )
       end
 
@@ -319,7 +353,7 @@ module Steep
         if sig.is_a?(AST::Signature::Class)
           unless sig.name == ModuleName.parse("::BasicObject")
             super_class_name = sig.super_class&.name || ModuleName.parse("::Object")
-            super_class_interface = build(TypeName::Instance.new(name: super_class_name), current: nil)
+            super_class_interface = build(TypeName::Instance.new(name: super_class_name), current: nil, with_initialize: with_initialize)
 
             supers.push(*super_class_interface.supers)
             instantiated = super_class_interface.instantiate(
@@ -357,51 +391,15 @@ module Steep
           when AST::Signature::Members::Method
             if member.instance_method?
               if with_initialize || member.name != :initialize
-                add_method(type_name, member, methods: methods)
+                extra_attrs = member.name == :initialize ? [:incompatible] : []
+                add_method(type_name, member, methods: methods, extra_attributes: extra_attrs)
               end
             end
           when AST::Signature::Members::Ivar
             merge_ivars(ivar_chains,
                         { member.name => absolute_type(member.type, current: sig.name) })
           when AST::Signature::Members::Attr
-            if member.ivar != false
-              ivar_name = member.ivar || "@#{member.name}".to_sym
-              merge_ivars(ivar_chains,
-                          { ivar_name => absolute_type(member.type, current: sig.name) })
-            end
-
-            reader_method = AST::Signature::Members::Method.new(
-              location: member.location,
-              name: member.name,
-              kind: :instance,
-              types: [
-                AST::MethodType.new(location: member.type.location,
-                                    type_params: nil,
-                                    params: nil,
-                                    block: nil,
-                                    return_type: member.type)
-              ],
-              attributes: []
-            )
-            add_method(type_name, reader_method, methods: methods)
-
-            if member.accessor?
-              writer_method = AST::Signature::Members::Method.new(
-                location: member.location,
-                name: "#{member.name}=".to_sym,
-                kind: :instance,
-                types: [
-                  AST::MethodType.new(location: member.type.location,
-                                      type_params: nil,
-                                      params: AST::MethodType::Params::Required.new(location: member.type.location,
-                                                                                    type: member.type),
-                                      block: nil,
-                                      return_type: member.type)
-                ],
-                attributes: []
-              )
-              add_method(type_name, writer_method, methods: methods)
-            end
+            merge_attribute(sig, ivar_chains, methods, type_name, member)
           end
         end
 
@@ -425,6 +423,47 @@ module Steep
         )
       end
 
+      def merge_attribute(sig, ivar_chains, methods, type_name, member)
+        if member.ivar != false
+          ivar_name = member.ivar || "@#{member.name}".to_sym
+          merge_ivars(ivar_chains,
+                      { ivar_name => absolute_type(member.type, current: sig.name) })
+        end
+
+        reader_method = AST::Signature::Members::Method.new(
+          location: member.location,
+          name: member.name,
+          kind: :instance,
+          types: [
+            AST::MethodType.new(location: member.type.location,
+                                type_params: nil,
+                                params: nil,
+                                block: nil,
+                                return_type: member.type)
+          ],
+          attributes: []
+        )
+        add_method(type_name, reader_method, methods: methods)
+
+        if member.accessor?
+          writer_method = AST::Signature::Members::Method.new(
+            location: member.location,
+            name: "#{member.name}=".to_sym,
+            kind: :instance,
+            types: [
+              AST::MethodType.new(location: member.type.location,
+                                  type_params: nil,
+                                  params: AST::MethodType::Params::Required.new(location: member.type.location,
+                                                                                type: member.type),
+                                  block: nil,
+                                  return_type: member.type)
+            ],
+            attributes: []
+          )
+          add_method(type_name, writer_method, methods: methods)
+        end
+      end
+
       def merge_ivars(dest, new_vars)
         new_vars.each do |name, new_type|
           dest[name] = IvarChain.new(type: new_type, parent: dest[name])
@@ -460,8 +499,12 @@ module Steep
         type_params = method_type.type_params&.variables || []
         params = params_to_params(method_type.params, current: current)
         block = method_type.block && Block.new(
-          params: params_to_params(method_type.block.params, current: current),
-          return_type: absolute_type(method_type.block.return_type, current: current)
+          type: AST::Types::Proc.new(
+            params: params_to_params(method_type.block.params, current: current),
+            return_type: absolute_type(method_type.block.return_type, current: current),
+            location: method_type.block.location,
+            ),
+          optional: method_type.block.optional
         )
 
         MethodType.new(

data/lib/steep/interface/instantiated.rb

@@ -85,7 +85,7 @@ module Steep
       end
 
       def validate_method(check, method)
-        if method.super_method
+        if method.super_method && !method.incompatible?
           result = check.check_method(method.name,
                                       method,
                                       method.super_method,

data/lib/steep/interface/method.rb

@@ -24,6 +24,10 @@ module Steep
           other.attributes == attributes
       end
 
+      def incompatible?
+        attributes.include?(:incompatible)
+      end
+
       def closed?
         types.all?(&:closed?)
       end
@@ -58,6 +62,10 @@ module Steep
         )
       end
 
+      def map_types
+        with_types(types.map {|type| yield type })
+      end
+
       def include_in_chain?(method)
         (method.type_name == type_name &&
           method.name == name &&

data/lib/steep/interface/method_type.rb

@@ -17,6 +17,18 @@ module Steep
         @rest_keywords = rest_keywords
       end
 
+      NONE = Object.new
+      def update(required: NONE, optional: NONE, rest: NONE, required_keywords: NONE, optional_keywords: NONE, rest_keywords: NONE)
+        self.class.new(
+          required: required.equal?(NONE) ? self.required : required,
+          optional: optional.equal?(NONE) ? self.optional : optional,
+          rest: rest.equal?(NONE) ? self.rest : rest,
+          required_keywords: required_keywords.equal?(NONE) ? self.required_keywords : required_keywords,
+          optional_keywords: optional_keywords.equal?(NONE) ? self.optional_keywords : optional_keywords,
+          rest_keywords: rest_keywords.equal?(NONE) ? self.rest_keywords : rest_keywords
+        )
+      end
+
       def self.empty
         self.new(
           required: [],
@@ -176,38 +188,53 @@ module Steep
         rest_keywords = self.rest_keywords ? ["**#{self.rest_keywords}"] : []
         "(#{(required + optional + rest + required_keywords + optional_keywords + rest_keywords).join(", ")})"
       end
+
+      def map_type(&block)
+        self.class.new(
+          required: required.map(&block),
+          optional: optional.map(&block),
+          rest: rest && yield(rest),
+          required_keywords: required_keywords.transform_values(&block),
+          optional_keywords: optional_keywords.transform_values(&block),
+          rest_keywords: rest_keywords && yield(rest_keywords)
+        )
+      end
     end
 
     class Block
-      attr_reader :params
-      attr_reader :return_type
+      attr_reader :type
+      attr_reader :optional
 
-      def initialize(params:, return_type:)
-        @params = params
-        @return_type = return_type
+      def initialize(type:, optional:)
+        @type = type
+        @optional = optional
+      end
+
+      def optional?
+        @optional
       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.optional == optional
       end
 
       def closed?
-        params.closed? && return_type.closed?
+        type.closed?
       end
 
       def subst(s)
         self.class.new(
-          params: params.subst(s),
-          return_type: return_type.subst(s)
+          type: type.subst(s),
+          optional: optional
         )
       end
 
       def free_variables
-        params.free_variables + return_type.free_variables
+        type.free_variables
       end
 
       def to_s
-        "{ #{params} -> #{return_type} }"
+        "#{optional? ? "?" : ""}{ #{type.params} -> #{type.return_type} }"
       end
     end
 
@@ -257,8 +284,8 @@ module Steep
         if block_given?
           params.each_type(&block)
           self.block&.tap do
-            self.block.params.each_type(&block)
-            yield(self.block.return_type)
+            self.block.type.params.each_type(&block)
+            yield(self.block.type.return_type)
           end
           yield(return_type)
         else