typeprof 0.4.2 → 0.5.4

data/lib/typeprof/block.rb

@@ -85,10 +85,13 @@ module TypeProf
     end
 
     def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
-      subst = { Type::Var.new(:self) => caller_env.static_env.recv_ty } # XXX: support other type variables
-      unless aargs.consistent_with_method_signature?(@msig, subst)
+      aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
+      subst = aargs.consistent_with_method_signature?(@msig)
+      unless subst
         scratch.warn(caller_ep, "The arguments is not compatibile to RBS block")
       end
+      # check?
+      #subst = { Type::Var.new(:self) => caller_env.static_env.recv_ty }
       # XXX: Update type vars
       ctn[@ret_ty, caller_ep, caller_env]
     end

data/lib/typeprof/builtin.rb

@@ -54,6 +54,10 @@ module TypeProf
       ctn[ret_ty, ep, env]
     end
 
+    def vmcore_raise(recv, mid, aargs, ep, env, scratch, &ctn)
+      # no-op
+    end
+
     def lambda(recv, mid, aargs, ep, env, scratch, &ctn)
       ctn[aargs.blk_ty, ep, env]
     end
@@ -63,10 +67,11 @@ module TypeProf
     end
 
     def object_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      ty = Type::Instance.new(recv)
       if recv.type_params.size >= 1
-        ty = Type::Cell.new(Type::Cell::Elements.new([Type.bot] * recv.type_params.size), ty)
+        ty = Type::ContainerType.create_empty_instance(recv)
         env, ty = scratch.localize_type(ty, env, ep, AllocationSite.new(ep).add_id(:object_s_new))
+      else
+        ty = Type::Instance.new(recv)
       end
       meths = scratch.get_method(recv, false, :initialize)
       meths.flat_map do |meth|
@@ -149,7 +154,11 @@ module TypeProf
 
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       arg = aargs.lead_tys[0]
-      scratch.include_module(recv, arg, ep.ctx.iseq.absolute_path)
+      arg.each_child do |arg|
+        if arg.is_a?(Type::Class)
+          scratch.include_module(recv, arg, false, ep.ctx.iseq.absolute_path)
+        end
+      end
       ctn[recv, ep, env]
     end
 
@@ -157,7 +166,7 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.extend_module(recv, arg, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, true, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
@@ -520,6 +529,7 @@ module TypeProf
       scratch.set_custom_method(klass_vmcore, :"core#set_method_alias", Builtin.method(:vmcore_set_method_alias))
       scratch.set_custom_method(klass_vmcore, :"core#undef_method", Builtin.method(:vmcore_undef_method))
       scratch.set_custom_method(klass_vmcore, :"core#hash_merge_kwd", Builtin.method(:vmcore_hash_merge_kwd))
+      scratch.set_custom_method(klass_vmcore, :"core#raise", Builtin.method(:vmcore_raise))
       scratch.set_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
       scratch.set_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
       scratch.set_singleton_custom_method(klass_obj, :"attr_accessor", Builtin.method(:module_attr_accessor))

data/lib/typeprof/config.rb

@@ -69,19 +69,23 @@ module TypeProf
     prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
     prologue_env = Env.new(StaticEnv.new(:top, Type.nil, false), [], [], Utils::HashWrapper.new({}))
 
-    Config.rb_files.each do |file|
-      if file.respond_to?(:read)
-        iseq = ISeq.compile_str(file.read, file.to_s)
+    Config.rb_files.each do |rb|
+      if rb.is_a?(Array) # [String name, String content]
+        iseq = ISeq.compile_str(*rb.reverse)
       else
-        iseq = ISeq.compile(file)
+        iseq = ISeq.compile(rb)
       end
       ep, env = TypeProf.starting_state(iseq)
       scratch.merge_env(ep, env)
       scratch.add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
     end
 
-    Config.rbs_files.each do |path|
-      Import.import_rbs_file(scratch, path)
+    Config.rbs_files.each do |rbs|
+      if rbs.is_a?(Array) # [String name, String content]
+        Import.import_rbs_code(scratch, *rbs)
+      else
+        Import.import_rbs_file(scratch, rbs)
+      end
     end
 
     result = scratch.type_profile

data/lib/typeprof/container-type.rb

@@ -19,13 +19,44 @@ module TypeProf
     # Cell, Array, and Hash are types for global interface, e.g., TypedISeq.
     # Do not push such types to local environment, stack, etc.
 
+    class ContainerType < Type
+      def match?(other)
+        return nil if self.class != other.class
+        return nil unless @base_type.consistent?(other.base_type)
+        @elems.match?(other.elems)
+      end
+
+      def each_free_type_variable(&blk)
+        @elems.each_free_type_variable(&blk)
+      end
+
+      def consistent?(other)
+        raise "must not be used"
+      end
+
+      def self.create_empty_instance(klass)
+        base_type = Type::Instance.new(klass)
+        case klass
+        when Type::Builtin[:ary] # XXX: check inheritance...
+          Type::Array.new(Type::Array::Elements.new([], Type.bot), base_type)
+        when Type::Builtin[:hash]
+          Type.gen_hash(base_type) {|h| }
+        else
+          Type::Cell.new(Type::Cell::Elements.new([Type.bot] * klass.type_params.size), base_type)
+        end
+      end
+    end
+
     # The most basic container type for default type parameter class
-    class Cell < Type
+    class Cell < ContainerType
       def initialize(elems, base_type)
         raise if !elems.is_a?(Cell::Elements)
         @elems = elems # Cell::Elements
         raise unless base_type
         @base_type = base_type
+        if base_type.klass.type_params.size != elems.elems.size
+          raise
+        end
       end
 
       attr_reader :elems, :base_type
@@ -44,7 +75,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:cell)
+        alloc_site = alloc_site.add_id(:cell).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth)
         env.deploy_type(LocalCell, alloc_site, elems, @base_type)
       end
@@ -58,31 +89,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Cell
-          @elems.size == other.elems.size &&
-            @base_type.consistent?(other.base_type, subst) &&
-            @elems.zip(other.elems).all? {|elem1, elem2| elem1..consistent?(elem2, subst) }
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth)
         Cell.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Cell
         include Utils::StructuralEquality
 
         def initialize(elems)
@@ -124,12 +137,21 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
-          false if @elems.size != other.elems.size
+        def match?(other)
+          return nil if @elems.size != other.elems.size
+          subst = nil
           @elems.zip(other.elems) do |ty0, ty1|
-            return false unless ty0.consistent?(ty1, subst)
+            subst2 = Type.match?(ty0, ty1)
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @elems.each do |ty|
+            ty.each_free_type_variable(&blk)
           end
-          return true
         end
 
         def substitute(subst, depth)
@@ -146,6 +168,9 @@ module TypeProf
 
         def union(other)
           return self if self == other
+          if @elems.size != other.elems.size
+            raise "#{ @elems.size } != #{ other.elems.size }"
+          end
           elems = []
           @elems.zip(other.elems) do |ty0, ty1|
             elems << ty0.union(ty1)
@@ -155,7 +180,7 @@ module TypeProf
       end
     end
 
-    class LocalCell < Type
+    class LocalCell < ContainerType
       def initialize(id, base_type)
         @id = id
         raise unless base_type
@@ -184,6 +209,7 @@ module TypeProf
           else
             elems = Cell::Elements.new([]) # XXX
           end
+          visited.delete(self)
           Cell.new(elems, @base_type)
         end
       end
@@ -191,14 +217,10 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
 
     # Do not insert Array type to local environment, stack, etc.
-    class Array < Type
+    class Array < ContainerType
       def initialize(elems, base_type)
         raise unless elems.is_a?(Array::Elements)
         @elems = elems # Array::Elements
@@ -223,7 +245,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:ary)
+        alloc_site = alloc_site.add_id(:ary).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
         env.deploy_type(LocalArray, alloc_site, elems, @base_type)
       end
@@ -237,29 +259,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Array
-          @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth - 1)
         Array.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Array
         include Utils::StructuralEquality
 
         def initialize(lead_tys, rest_ty = Type.bot)
@@ -300,6 +306,9 @@ module TypeProf
 
         def screen_name(scratch)
           if Config.options[:show_container_raw_elements] || @rest_ty == Type.bot
+            if @lead_tys.empty?
+              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+            end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
             end
@@ -318,14 +327,24 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
+        def match?(other)
           n = [@lead_tys.size, other.lead_tys.size].min
-          n.times do |i|
-            return false unless @lead_tys[i].consistent?(other.lead_tys[i], subst)
-          end
           rest_ty1 = @lead_tys[n..].inject(@rest_ty) {|ty1, ty2| ty1.union(ty2) }
           rest_ty2 = other.lead_tys[n..].inject(other.rest_ty) {|ty1, ty2| ty1.union(ty2) }
-          rest_ty1.consistent?(rest_ty2, subst)
+          subst = nil
+          (@lead_tys[0, n] + [rest_ty1]).zip(other.lead_tys[0, n] + [rest_ty2]) do |ty0, ty1|
+            subst2 = Type.match?(ty0, ty1)
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @lead_tys.each do |ty|
+            ty.each_free_type_variable(&blk)
+          end
+          @rest_ty&.each_free_type_variable(&blk)
         end
 
         def substitute(subst, depth)
@@ -476,7 +495,7 @@ module TypeProf
     end
 
     # Do not insert Array type to local environment, stack, etc.
-    class LocalArray < Type
+    class LocalArray < ContainerType
       def initialize(id, base_type)
         @id = id
         raise unless base_type
@@ -506,6 +525,7 @@ module TypeProf
             # TODO: currently out-of-scope array cannot be accessed
             elems = Array::Elements.new([], Type.any)
           end
+          visited.delete(self)
           Array.new(elems, @base_type)
         end
       end
@@ -513,14 +533,10 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
 
 
-    class Hash < Type
+    class Hash < ContainerType
       def initialize(elems, base_type)
         @elems = elems
         raise unless elems
@@ -539,7 +555,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:hash)
+        alloc_site = alloc_site.add_id(:hash).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
         env.deploy_type(LocalHash, alloc_site, elems, @base_type)
       end
@@ -553,29 +569,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Hash
-          @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth - 1)
         Hash.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Hash
         include Utils::StructuralEquality
 
         def initialize(map_tys)
@@ -634,12 +634,22 @@ module TypeProf
         end
 
         def screen_name(scratch)
-          s = @map_tys.map do |k_ty, v_ty|
-            k = k_ty.screen_name(scratch)
-            v = v_ty.screen_name(scratch)
-            "#{ k }=>#{ v }"
-          end.join(", ")
-          "{#{ s }}"
+          if !@map_tys.empty? && @map_tys.all? {|k_ty,| k_ty.is_a?(Type::Symbol) }
+            s = @map_tys.map do |k_ty, v_ty|
+              v = v_ty.screen_name(scratch)
+              "#{ k_ty.sym }: #{ v }"
+            end.join(", ")
+            "{#{ s }}"
+          else
+            k_ty = v_ty = Type.bot
+            @map_tys.each do |k, v|
+              k_ty = k_ty.union(k)
+              v_ty = v_ty.union(v)
+            end
+            k_ty = k_ty.screen_name(scratch)
+            v_ty = v_ty.screen_name(scratch)
+            "Hash[#{ k_ty }, #{ v_ty }]"
+          end
         end
 
         def pretty_print(q)
@@ -657,22 +667,31 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
-          subst2 = subst.dup
+        def match?(other)
+          subst = nil
           other.map_tys.each do |k1, v1|
-            found = false
+            subst2 = nil
             @map_tys.each do |k0, v0|
-              subst3 = subst2.dup
-              if k0.consistent?(k1, subst3) && v0.consistent?(v1, subst3)
-                subst2.replace(subst3)
-                found = true
-                break
+              subst3 = Type.match?(k0, k1)
+              if subst3
+                subst4 = Type.match?(v0, v1)
+                if subst4
+                  subst2 = Type.merge_substitution(subst2, subst3)
+                  subst2 = Type.merge_substitution(subst2, subst4)
+                end
               end
             end
-            return false unless found
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @map_tys.each do |k, v|
+            k.each_free_type_variable(&blk)
+            v.each_free_type_variable(&blk)
           end
-          subst.replace(subst2)
-          true
         end
 
         def substitute(subst, depth)
@@ -706,7 +725,7 @@ module TypeProf
         def [](key_ty)
           val_ty = Type.bot
           @map_tys.each do |k_ty, v_ty|
-            if k_ty.consistent?(key_ty, {})
+            if Type.match?(k_ty, key_ty)
               val_ty = val_ty.union(v_ty)
             end
           end
@@ -763,7 +782,7 @@ module TypeProf
       end
     end
 
-    class LocalHash < Type
+    class LocalHash < ContainerType
       def initialize(id, base_type)
         @id = id
         @base_type = base_type
@@ -791,6 +810,7 @@ module TypeProf
           else
             elems = Hash::Elements.new({Type.any => Type.any})
           end
+          visited.delete(self)
           Hash.new(elems, @base_type)
         end
       end
@@ -798,10 +818,6 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
   end
 end