steep 0.1.0.pre → 0.1.0.pre2

data/lib/steep/signature/errors.rb

@@ -22,6 +22,10 @@ module Steep
           super(signature: signature)
           @type = type
         end
+
+        def puts(io)
+          io.puts "UnknownTypeName: signature=#{signature.name}, type=#{type}"
+        end
       end
 
       class IncompatibleOverride < Base
@@ -40,6 +44,10 @@ module Steep
           @this_method = this_method
           @super_method = super_method
         end
+
+        def puts(io)
+          io.puts "IncompatibleOverride: signature=#{signature.name}, method=#{method_name}"
+        end
       end
 
       class InvalidTypeApplication < Base
@@ -51,6 +59,10 @@ module Steep
           @type_name = type_name
           @type_args = type_args
         end
+
+        def puts(io)
+          io.puts "InvalidTypeApplication: signature=#{signature.name}, type_name=#{type_name}, type_args=#{type_args}"
+        end
       end
 
       class InvalidSelfType < Base
@@ -60,6 +72,11 @@ module Steep
           super(signature: signature)
           @member = member
         end
+
+
+        def puts(io)
+          io.puts "InvalidSelfType: signature=#{signature.name}, module=#{member.name}"
+        end
       end
 
       class UnexpectedTypeNameKind < Base
@@ -71,6 +88,17 @@ module Steep
           @type = type
           @expected_kind = expected_kind
         end
+
+
+        def puts(io)
+          io.puts "UnexpectedTypeNameKind: signature=#{signature.name}, type=#{type}, kind=#{expected_kind}"
+        end
+      end
+
+      class ConstructorNoCheck < Base
+        def puts(io)
+          io.puts "ConstructorNoCheck: signature=#{signature.name}"
+        end
       end
     end
   end

data/lib/steep/signature/interface.rb

@@ -32,11 +32,12 @@ module Steep
         # @type var map: Hash<Symbol, Steep__Type>
         map = Hash[self.params.zip(params)]
         Steep::Interface.new(name: name,
+                             params: params,
                              methods: methods.transform_values {|method|
                                types = method.map {|method_type|
                                  method_type.substitute(klass: klass, instance: instance, params: map)
                                }
-                               Steep::Interface::Method.new(types: types, super_method: nil)
+                               Steep::Interface::Method.new(types: types, super_method: nil, attributes: [])
                              })
       end
 

data/lib/steep/type_assignability.rb

@@ -70,7 +70,7 @@ module Steep
     end
 
     def test_interface(src, dest, known_pairs)
-      if src.name == dest.name
+      if src == dest
         return true
       end
 
@@ -140,7 +140,7 @@ module Steep
             assigning_pairs << [src.rest, dest_type.last]
           end
         end
-      when src.required.size + src.optional.size >= dest.required.size + dest.optional.size && !src.rest
+      when src.required.size + src.optional.size >= dest.required.size + dest.optional.size
         while src_flat.size > 0
           src_type = src_flat.shift
           dest_type = dest_flat.shift
@@ -148,7 +148,11 @@ module Steep
           if dest_type
             assigning_pairs << [src_type.last, dest_type.last]
           else
-            break
+            if src_type.first == :required
+              return false
+            else
+              break
+            end
           end
         end
       else
@@ -216,7 +220,7 @@ module Steep
       test(src: dest.return_type, dest: src.return_type, known_pairs: known_pairs)
     end
 
-    def resolve_interface(name, params, klass: nil, instance: nil)
+    def resolve_interface(name, params, klass: nil, instance: nil, constructor: nil)
       klass ||= Types::Name.module(name: name.name, params: params)
       instance ||= Types::Name.instance(name: name.name, params: params)
 
@@ -225,10 +229,10 @@ module Steep
         signatures[name.name].to_interface(klass: klass, instance: instance, params: params)
       when TypeName::Instance
         methods = signatures[name.name].instance_methods(assignability: self, klass: klass, instance: instance, params: params)
-        Interface.new(name: name, methods: methods)
+        Interface.new(name: name, params: params, methods: methods.reject {|key, _| key == :initialize })
       when TypeName::Module
-        methods = signatures[name.name].module_methods(assignability: self, klass: klass, instance: instance, params: params)
-        Interface.new(name: name, methods: methods)
+        methods = signatures[name.name].module_methods(assignability: self, klass: klass, instance: instance, params: params, constructor: constructor)
+        Interface.new(name: name, params: params, methods: methods)
       else
         raise "Unexpected type name: #{name.inspect}"
       end
@@ -284,7 +288,8 @@ module Steep
         }
         method = methods[name]
       when Types::Name
-        interface = resolve_interface(type.name, type.params)
+        constructor = type.name.is_a?(TypeName::Module) && type.name.constructor
+        interface = resolve_interface(type.name, type.params, constructor: constructor)
         method = interface.methods[name]
       else
         raise "Unexpected type: #{type}"

data/lib/steep/type_construction.rb

@@ -3,12 +3,14 @@ module Steep
     class MethodContext
       attr_reader :name
       attr_reader :method
+      attr_reader :constructor
 
-      def initialize(name:, method:, method_type:, return_type:)
+      def initialize(name:, method:, method_type:, return_type:, constructor:)
         @name = name
         @method = method
         @return_type = return_type
         @method_type = method_type
+        @constructor = constructor
       end
 
       def return_type
@@ -87,7 +89,7 @@ module Steep
       end
 
       if (type = annotations.lookup_method_type(method_name))
-        Interface::Method.new(types: [type], super_method: entry&.super_method)
+        Interface::Method.new(types: [type], super_method: entry&.super_method, attributes: [])
       else
         entry
       end
@@ -110,11 +112,15 @@ module Steep
         var_types = {}
       end
 
+      # FIXME: reading signature directory does not look good...
+      constructor_method = entry&.attributes&.include?(:constructor)
+
       method_context = MethodContext.new(
         name: method_name,
         method: entry,
         method_type: annotations.lookup_method_type(method_name),
         return_type: annots.return_type,
+        constructor: constructor_method
       )
 
       ivar_types = annots.ivar_types.keys.each.with_object({}) do |var, env|
@@ -213,7 +219,18 @@ module Steep
         end
 
       when :send
-        type_send(node, with_block: false)
+        if self_class?(node)
+          module_type = module_context.module_type
+          type = if module_type.is_a?(Types::Name)
+                   Types::Name.new(name: module_type.name.updated(constructor: method_context.constructor),
+                                   params: module_type.params)
+                 else
+                   module_type
+                 end
+          typing.add_typing(node, type)
+        else
+          type_send(node, with_block: false)
+        end
 
       when :super
         if self_type && method_context&.method
@@ -449,6 +466,8 @@ module Steep
       when :module
         annots = source.annotations(block: node)
 
+        module_type = Types::Name.instance(name: :Module)
+
         if annots.implement_module
           signature = assignability.signatures[annots.implement_module]
           raise "Module instance should be an module: #{annots.instance_type || annots.implment_module}" unless signature.is_a?(Signature::Module)
@@ -456,19 +475,31 @@ module Steep
           ty = Types::Name.instance(name: annots.implement_module)
 
           if signature.self_type
-            instance_type = Types::Merge.new(types: [signature.self_type, ty])
+            instance_type = Types::Merge.new(types: [Types::Name.instance(name: :Object),
+                                                     signature.self_type,
+                                                     ty])
           else
-            instance_type = ty
+            instance_type = Types::Merge.new(types: [Types::Name.instance(name: :Object),
+                                                     ty])
           end
+
+          module_type = Types::Merge.new(types: [
+            Types::Name.instance(name: :Module),
+            Types::Name.module(name: annots.implement_module)
+          ])
         end
 
         if annots.instance_type
           instance_type = annots.instance_type
         end
 
+        if annots.module_type
+          module_type = annots.module_type
+        end
+
         module_context_ = ModuleContext.new(
           instance_type: instance_type,
-          module_type: annots.module_type,
+          module_type: module_type,
           const_types: annots.const_types
         )
 
@@ -989,5 +1020,9 @@ module Steep
       typing.add_error Errors::FallbackAny.new(node: node)
       typing.add_typing node, Types::Any.new
     end
+
+    def self_class?(node)
+      node.type == :send && node.children[0]&.type == :self && node.children[1] == :class
+    end
   end
 end

data/lib/steep/type_name.rb

@@ -27,8 +27,38 @@ module Steep
     class Interface < Base; end
 
     class Module < Base
+      attr_reader :constructor
+
       def to_s
-        "#{name}.module"
+        k = case constructor
+            when nil
+              ""
+            when true
+              " constructor"
+            when false
+              " noconstructor"
+            end
+
+        "#{name}.module#{k}"
+      end
+
+      def initialize(name:, constructor:)
+        super(name: name)
+        @constructor = constructor
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.name == name && other.constructor == constructor
+      end
+
+      NOTHING = Object.new
+
+      def updated(constructor: NOTHING)
+        if NOTHING == constructor
+          constructor = self.constructor
+        end
+
+        self.class.new(name: name, constructor: constructor)
       end
     end
 

data/lib/steep/types/name.rb

@@ -21,8 +21,8 @@ module Steep
         self.new(name: TypeName::Interface.new(name: name), params: params)
       end
 
-      def self.module(name:, params: [])
-        self.new(name: TypeName::Module.new(name: name), params: params)
+      def self.module(name:, params: [], constructor: nil)
+        self.new(name: TypeName::Module.new(name: name, constructor: constructor), params: params)
       end
 
       def self.instance(name:, params: [])

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.1.0.pre"
+  VERSION = "0.1.0.pre2"
 end

data/sig/signature.rbi

@@ -1,6 +1,7 @@
 class Steep__Signature__Error
   def initialize: (signature: Steep__Signature) -> any
   def signature: -> Steep__Signature
+  def puts: (any) -> any
 end
 
 class Steep__Signature__Errors__UnknownTypeName <: Steep__Signature__Error
@@ -8,8 +9,21 @@ class Steep__Signature__Errors__UnknownTypeName <: Steep__Signature__Error
   def type: -> Steep__Type
 end
 
+class Steep__BlockType
+  def params: -> Steep__MethodParams
+  def return_type: -> Steep__Type
+end
+
+class Steep__MethodParams
+  def each_type: { (Steep__Type) -> any } -> instance
+end
+
 class Steep__MethodType
   def substitute: (klass: Steep__Type, instance: Steep__Type, params: Hash<Symbol, Steep__Type>) -> Steep__MethodType
+  def updated: (?type_params: Array<Symbol>, ?params: Steep__MethodParams, ?block: any, ?return_type: Steep__Type) -> Steep__MethodType
+  def params: -> Steep__MethodParams
+  def return_type: -> Steep__Type
+  def block: -> Steep__BlockType
 end
 
 class Steep__Interface
@@ -19,6 +33,7 @@ end
 class Steep__Method
   def initialize: (types: Array<Steep__MethodType>, super_method: Steep__Method) -> any
   def substitute: (klass: Steep__Type, instance: Steep__Type, params: Hash<Symbol, Steep__Type>) -> Steep__Method
+  def types: -> Array<Steep__MethodType>
 end
 
 class Steep__Signature
@@ -34,6 +49,83 @@ class Steep__Signature__Errors__IncompatibleOverride <: Steep__Signature__Error
   def super_method: -> Steep__Method
 end
 
+class Steep__SignatureMember__Method <: Steep__Signature__Member
+  def initialize: (name: Symbol, types: Array<Steep__MethodType>) -> any
+  def name: -> Symbol
+  def types: -> Array<Steep__MethodType>
+end
+
+class Steep__SignatureMember__Include <: Steep__Signature__Member
+  def initialize: (name: Symbol) -> any
+  def name: -> Symbol
+end
+
+class Steep__SignatureMember__Extend <: Steep__Signature__Member
+  def initialize: (name: Symbol) -> any
+  def name: -> Symbol
+end
+
+interface _Steep__SignatureMember__Mixin
+  def name: -> Steep__Type
+end
+
+interface _Steep__WithMethods
+  def instance_methods: (assignability: any, klass: Steep__Type, instance: Steep__Type, params: Array<Steep__Type>) -> Hash<Symbol, Steep__Method>
+  def module_methods: (assignability: any, klass: Steep__Type, instance: Steep__Type, params: Array<Steep__Type>) -> Hash<Symbol, Steep__Method>
+  def type_application_hash: (Array<Steep__Type>) -> Hash<Symbol, Steep__Type>
+  def members: -> Array<Steep__Signature__Member>
+  def is_class?: -> _Boolean
+end
+
+module Steep__Signature__WithMethods : _Steep__WithMethods
+  def instance_methods: (assignability: any, klass: Steep__Type, instance: Steep__Type, params: Array<Steep__Type>) -> Hash<Symbol, Steep__Method>
+  def module_methods: (assignability: any, klass: Steep__Type, instance: Steep__Type, params: Array<Steep__Type>) -> Hash<Symbol, Steep__Method>
+  def merge_methods: (Hash<Symbol, Steep__Method>, Hash<Symbol, Steep__Method>) -> Hash<Symbol, Steep__Method>
+end
+
+interface _Steep__WithMembers
+  def members: -> Array<Steep__Signature__Member>
+  def params: -> Array<Symbol>
+end
+
+module Steep__Signature__WithMembers : _Steep__WithMembers
+  def each_type: { (Steep__Type) -> any } -> any
+  def validate_mixins: (any, Steep__Interface) -> any
+end
+
+interface _Steep__WithParams
+end
+
+module Steep__Signature__WithParams : _Steep__WithParams
+  def type_application_hash: (Array<Steep__Type>) -> Hash<Symbol, Steep__Type>
+end
+
+class Steep__Signature__Module
+  include Steep__Signature__WithMethods
+  include Steep__Signature__WithMembers
+  include Steep__Signature__WithParams
+
+  def initialize: (name: Symbol, params: Array<Symbol>, members: Array<Steep__Signature__Member>, self_type: Steep__Type) -> any
+  def name: -> Symbol
+  def params: -> Array<Symbol>
+  def members: -> Array<Steep__Signature__Member>
+  def self_type: -> Steep__Type
+  def is_class?: -> _Boolean
+end
+
+class Steep__Signature__Class
+  include Steep__Signature__WithMethods
+  include Steep__Signature__WithMembers
+  include Steep__Signature__WithParams
+
+  def initialize: (name: Symbol, params: Array<Symbol>, members: Array<Steep__Signature__Member>, super_class: Steep__Types__Name) -> any
+  def name: -> Symbol
+  def params: -> Array<Symbol>
+  def members: -> Array<Steep__Signature__Member>
+  def super_class: -> Steep__Types__Name
+  def is_class?: -> _Boolean
+end
+
 class Steep__Signature__Extension
   def initialize: (module_name: Symbol, extension_name: Symbol, members: Array<Steep__Signature__Member>) -> any
   def module_name: -> Symbol

data/smoke/array/b.rb

@@ -0,0 +1,16 @@
+x = ""
+y = 1
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+x = y
+# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=String
+y = x
+
+# @type var a: Array<Integer>
+# @type var b: Array<String>
+
+a = []
+# !expects IncompatibleAssignment: lhs_type=Array<String>, rhs_type=Array<Integer>
+b = a
+# !expects IncompatibleAssignment: lhs_type=Array<Integer>, rhs_type=Array<String>
+a = b

data/smoke/class/a.rbi

@@ -7,3 +7,18 @@ end
 class B
   def name: -> String
 end
+
+class C
+  def (constructor) foo: -> instance
+  def bar: -> instance
+end
+
+class D
+  def initialize: (String) -> any
+  def foo: -> any
+end
+
+class E
+  def initialize: () -> any
+  def foo: -> any
+end