typeprof 0.2.0 → 0.5.0

data/lib/typeprof/container-type.rb

@@ -6,30 +6,226 @@ module TypeProf
       raise if !val.is_a?(Utils::StructuralEquality) && !val.is_a?(Integer) && !val.is_a?(Symbol)
       @val = val
       @parent = parent
-      @_hash ||= (@val.hash ^ @parent.hash)
     end
 
     attr_reader :val, :parent
 
-    def hash
-      @_hash
-    end
-
     def add_id(val)
       AllocationSite.new(val, self)
     end
   end
 
   class Type # or AbstractValue
-    # This is a type for global interface, e.g., TypedISeq.
+    # 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 < 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
+
+      def inspect
+        "Type::Cell[#{ @elems.inspect }, base_type: #{ @base_type.inspect }]"
+      end
+
+      def screen_name(scratch)
+        str = @elems.screen_name(scratch)
+        if str.start_with?("*")
+          str = @base_type.screen_name(scratch) + str[1..]
+        end
+        str
+      end
+
+      def localize(env, alloc_site, depth)
+        return env, Type.any if depth <= 0
+        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
+
+      def limit_size(limit)
+        return Type.any if limit <= 0
+        Cell.new(@elems.limit_size(limit - 1), @base_type)
+      end
+
+      def get_method(mid, scratch)
+        raise
+      end
+
+      def substitute(subst, depth)
+        return Type.any if depth <= 0
+        elems = @elems.substitute(subst, depth)
+        Cell.new(elems, @base_type)
+      end
+
+      class Elements # Cell
+        include Utils::StructuralEquality
+
+        def initialize(elems)
+          @elems = elems
+        end
+
+        attr_reader :elems
+
+        def to_local_type(id, base_ty)
+          Type::LocalCell.new(id, base_ty)
+        end
+
+        def globalize(env, visited, depth)
+          Elements.new(@elems.map {|ty| ty.globalize(env, visited, depth) })
+        end
+
+        def localize(env, alloc_site, depth)
+          elems = @elems.map.with_index do |ty, i|
+            alloc_site2 = alloc_site.add_id(i)
+            env, ty = ty.localize(env, alloc_site2, depth)
+            ty
+          end
+          return env, Elements.new(elems)
+        end
+
+        def limit_size(limit)
+          Elements.new(@elems.map {|ty| ty.limit_size(limit) })
+        end
+
+        def screen_name(scratch)
+          "*[#{ @elems.map {|ty| ty.screen_name(scratch) }.join(", ") }]"
+        end
+
+        def pretty_print(q)
+          q.group(9, "Elements[", "]") do
+            q.seplist(@elems) do |elem|
+              q.pp elem
+            end
+          end
+        end
+
+        def match?(other)
+          return nil if @elems.size != other.elems.size
+          subst = nil
+          @elems.zip(other.elems) 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)
+          @elems.each do |ty|
+            ty.each_free_type_variable(&blk)
+          end
+        end
+
+        def substitute(subst, depth)
+          Elements.new(@elems.map {|ty| ty.substitute(subst, depth) })
+        end
+
+        def [](idx)
+          @elems[idx]
+        end
+
+        def update(idx, ty)
+          Elements.new(Utils.array_update(@elems, idx, @elems[idx].union(ty)))
+        end
+
+        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)
+          end
+          Elements.new(elems)
+        end
+      end
+    end
+
+    class LocalCell < ContainerType
+      def initialize(id, base_type)
+        @id = id
+        raise unless base_type
+        @base_type = base_type
+      end
+
+      attr_reader :id, :base_type
+
+      def inspect
+        "Type::LocalCell[#{ @id }, base_type: #{ @base_type.inspect }]"
+      end
+
+      def screen_name(scratch)
+        #raise "LocalArray must not be included in signature"
+        "LocalCell!"
+      end
+
+      def globalize(env, visited, depth)
+        if visited[self] || depth <= 0
+          Type.any
+        else
+          visited[self] = true
+          elems = env.get_container_elem_types(@id)
+          if elems
+            elems = elems.globalize(env, visited, depth - 1)
+          else
+            elems = Cell::Elements.new([]) # XXX
+          end
+          visited.delete(self)
+          Cell.new(elems, @base_type)
+        end
+      end
+
+      def get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
+      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
         raise unless base_type
         @base_type = base_type
-        # XXX: need infinite recursion
       end
 
       attr_reader :elems, :base_type
@@ -47,18 +243,11 @@ module TypeProf
         str
       end
 
-      def globalize(env, visited, depth)
-        return Type.any if depth <= 0
-        elems = @elems.globalize(env, visited, depth - 1)
-        base_ty = @base_type.globalize(env, visited, depth - 1)
-        Array.new(elems, base_ty)
-      end
-
       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_array_type(alloc_site, elems, @base_type)
+        env.deploy_type(LocalArray, alloc_site, elems, @base_type)
       end
 
       def limit_size(limit)
@@ -70,28 +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
-        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)
@@ -102,8 +276,7 @@ module TypeProf
 
         attr_reader :lead_tys, :rest_ty
 
-        def to_local_type(id)
-          base_ty = Type::Instance.new(Type::Builtin[:ary])
+        def to_local_type(id, base_ty)
           Type::LocalArray.new(id, base_ty)
         end
 
@@ -151,14 +324,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)
@@ -171,6 +354,11 @@ module TypeProf
           @lead_tys.inject(@rest_ty) {|ty1, ty2| ty1.union(ty2) } #.union(Type.nil) # is this needed?
         end
 
+        def squash_or_any
+          ty = squash
+          ty == Type.bot ? Type.any : ty
+        end
+
         def [](idx)
           if idx >= 0
             if idx < @lead_tys.size
@@ -304,7 +492,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
@@ -334,6 +522,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
@@ -341,14 +530,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
@@ -365,18 +550,11 @@ module TypeProf
         @elems.screen_name(scratch)
       end
 
-      def globalize(env, visited, depth)
-        return Type.any if depth <= 0
-        elems = @elems.globalize(env, visited, depth - 1)
-        base_ty = @base_type.globalize(env, visited, depth - 1)
-        Hash.new(elems, base_ty)
-      end
-
       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_hash_type(alloc_site, elems, @base_type)
+        env.deploy_type(LocalHash, alloc_site, elems, @base_type)
       end
 
       def limit_size(limit)
@@ -388,28 +566,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
-        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)
@@ -427,8 +590,7 @@ module TypeProf
 
         attr_reader :map_tys
 
-        def to_local_type(id)
-          base_ty = Type::Instance.new(Type::Builtin[:hash])
+        def to_local_type(id, base_ty)
           Type::LocalHash.new(id, base_ty)
         end
 
@@ -470,9 +632,13 @@ module TypeProf
 
         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 }"
+            if k_ty.is_a?(Type::Symbol)
+              "#{ k_ty.sym }: #{ v }"
+            else
+              k = k_ty.screen_name(scratch)
+              "#{ k }=>#{ v }"
+            end
           end.join(", ")
           "{#{ s }}"
         end
@@ -492,22 +658,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)
@@ -541,7 +716,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
@@ -579,10 +754,26 @@ module TypeProf
 
           Elements.new(map_tys)
         end
+
+        def to_keywords
+          kw_tys = {}
+          @map_tys.each do |key_ty, val_ty|
+            if key_ty.is_a?(Type::Symbol)
+              kw_tys[key_ty.sym] = val_ty
+            else
+              all_val_ty = Type.bot
+              @map_tys.each do |_key_ty, val_ty|
+                all_val_ty = all_val_ty.union(val_ty)
+              end
+              return { nil => all_val_ty }
+            end
+          end
+          kw_tys
+        end
       end
     end
 
-    class LocalHash < Type
+    class LocalHash < ContainerType
       def initialize(id, base_type)
         @id = id
         @base_type = base_type
@@ -610,6 +801,7 @@ module TypeProf
           else
             elems = Hash::Elements.new({Type.any => Type.any})
           end
+          visited.delete(self)
           Hash.new(elems, @base_type)
         end
       end
@@ -617,10 +809,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