typeprof 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ffa092b1a33661649a9a3b48347d78baf5d9bac0ba4020f72a122442d4d287
-  data.tar.gz: fbe985ca3547bd831564f5921f38edf65160c86133bb0219596aaa4e5962066a
+  metadata.gz: c1cf845328dbfd7b8dc14113c986be27a28457153d4e3b470ca45341035bdff7
+  data.tar.gz: 7e1aa96c7623832dc63e0d60573c28deeb0112c31921d63752553dcbf8127fde
 SHA512:
-  metadata.gz: b260426c710befa65825fc41998643ced8ef3b43d4edc16b5eb9a2f00cbaf865c832f80ee3443c6a8e9f725e5def2d6bd47a1109e97dffaab8d17771035ae08a
-  data.tar.gz: 47cf9f339601864c16464859d92aa9b904e51c471da84c2f2997519947edbc9c647b1762129cc0d677264fe0c0372de56acf04e98968a7b6e1c372d43af8a543
+  metadata.gz: 40e5f8da50d3b31dc96f2b010275083d9907c7510d16afc1f86b23114196a30c8170b9fc77cb8d8e1de0a7ba0b14a5deaf143450f3541e007a56a9170ce7ed93
+  data.tar.gz: 3fd01d2edc108f2ce262af023886fa04c8e2cbc6e98647dad238954428a188aa4637913c2e7f13c983deeb4ac6ff7b3dc3489acc740effcbddbd128519135662

data/.github/workflows/main.yml

@@ -17,9 +17,8 @@ jobs:
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
-    - name: Set up RBS and bundle install
+    - name: Bundle install
       run: |
-        cd rbs && bundle install && bundle exec rake parser && cd ..
         bundle install
     - name: Run the test suite
       run: |

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.4.1)
+    typeprof (0.4.2)
       rbs (>= 0.16.0)
 
 GEM

data/README.md

@@ -33,3 +33,9 @@ end
 ## Documentation
 
 [English](doc/doc.md) / [日本語](doc/doc.ja.md)
+
+## Playground
+
+You can try typeprof gem on the Web via the URL below.
+
+https://mame.github.io/typeprof-playground/

data/lib/typeprof/analyzer.rb

@@ -87,6 +87,11 @@ module TypeProf
       @recv_ty = recv_ty
       @blk_ty = blk_ty
       @mod_func = mod_func
+
+      return if recv_ty == :top #OK
+      recv_ty.each_child_global do |ty|
+        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && ty != Type.any
+      end
     end
 
     attr_reader :recv_ty, :blk_ty, :mod_func
@@ -129,11 +134,7 @@ module TypeProf
             elems2 = type_params[id]
             if elems2
               if elems != elems2
-                if elems.is_a?(Array) # should be refactored as Cell::Elements
-                  type_params[id] = elems.zip(elems2).map {|elem1, elem2| elem1.union(elem2) }
-                else
-                  type_params[id] = elems.union(elems2)
-                end
+                type_params[id] = elems.union(elems2)
               end
             else
               type_params[id] = elems
@@ -151,6 +152,8 @@ module TypeProf
       tys.each do |ty|
         raise "nil cannot be pushed to the stack" if ty.nil?
         ty.each_child do |ty|
+          raise if ty.is_a?(Type::Var)
+          #raise if ty.is_a?(Type::Instance) && ty.klass.type_params.size > 1
           raise "Array cannot be pushed to the stack" if ty.is_a?(Type::Array)
           raise "Hash cannot be pushed to the stack" if ty.is_a?(Type::Hash)
         end
@@ -572,9 +575,7 @@ module TypeProf
 
       ret_ty = @return_values[callee_ctx] ||= Type.bot
       if ret_ty != Type.bot
-        @callsites[callee_ctx].each do |caller_ep, ctn|
-          ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
-        end
+        ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
       end
     end
 
@@ -632,7 +633,7 @@ module TypeProf
         entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new)
         if ep
           if entry.rbs_declared
-            if !entry.type.consistent?(ty, {})
+            unless Type.match?(ty, entry.type)
               scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
               return
             end
@@ -651,6 +652,7 @@ module TypeProf
     end
 
     def get_ivar(recv)
+      recv = recv.base_type while recv.respond_to?(:base_type)
       case recv
       when Type::Class
         [@class_defs[recv.idx], true]
@@ -884,26 +886,41 @@ module TypeProf
     def pend_method_execution(iseq, meth, recv, mid, cref)
       ctx = Context.new(iseq, cref, mid)
       ep = ExecutionPoint.new(ctx, 0, nil)
-      locals = [Type.any] * iseq.locals.size
-
-      keyword = iseq.fargs_format[:keyword]
+      locals = [Type.nil] * iseq.locals.size
+
+      fargs_format = iseq.fargs_format
+      lead_num = fargs_format[:lead_num] || 0
+      post_num = fargs_format[:post_num] || 0
+      post_index = fargs_format[:post_start]
+      rest_index = fargs_format[:rest_start]
+      keyword = fargs_format[:keyword]
+      kw_index = fargs_format[:kwbits] - keyword.size if keyword
+      kwrest_index = fargs_format[:kwrest]
+      block_index = fargs_format[:block_start]
+      opt = fargs_format[:opt] || [0]
+
+      (lead_num + opt.size - 1).times {|i| locals[i] = Type.any }
+      post_num.times {|i| locals[i + post_index] = Type.any } if post_index
+      locals[rest_index] = Type.any if rest_index
       if keyword
-        kw_start = iseq.fargs_format[:kwbits]
-        kw_start -= iseq.fargs_format[:keyword].size if kw_start
         keyword.each_with_index do |kw, i|
           case
           when kw.is_a?(Symbol) # required keyword
+            locals[kw_index + i] = Type.any
           when kw.size == 2 # optional keyword (default value is a literal)
             _key, default_ty = *kw
             default_ty = Type.guess_literal_type(default_ty)
-            default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
-            locals[kw_start + i] = default_ty.union(Type.any)
+            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
+            locals[kw_index + i] = default_ty.union(Type.any)
           else # optional keyword (default value is an expression)
+            locals[kw_index + i] = Type.any
           end
         end
       end
+      locals[kwrest_index] = Type.any if kwrest_index
+      locals[block_index] = Type.nil if block_index
 
-      env = Env.new(StaticEnv.new(recv, Type.any, false), locals, [], Utils::HashWrapper.new({}))
+      env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
 
       @pending_execution[iseq] ||= [:method, [meth, ep, env]]
     end
@@ -986,7 +1003,7 @@ module TypeProf
             when kw.size == 2 # optional keyword (default value is a literal)
               key, default_ty = *kw
               default_ty = Type.guess_literal_type(default_ty)
-              default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
+              default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
               req = false
             else # optional keyword (default value is an expression)
               key, = kw
@@ -1029,7 +1046,17 @@ module TypeProf
         ty = Type::Literal.new(str, Type::Instance.new(Type::Builtin[:str]))
         env = env.push(ty)
       when :putself
-        env, ty = localize_type(env.static_env.recv_ty, env, ep)
+        ty = env.static_env.recv_ty
+        if ty.is_a?(Type::Instance)
+          klass = ty.klass
+          if klass.type_params.size >= 1
+            ty = Type::ContainerType.create_empty_instance(klass)
+            env, ty = localize_type(ty, env, ep, AllocationSite.new(ep))
+          else
+            ty = Type::Instance.new(klass)
+          end
+          env, ty = localize_type(ty, env, ep)
+        end
         env = env.push(ty)
       when :newarray, :newarraykwsplat
         len, = operands
@@ -1700,15 +1727,27 @@ module TypeProf
         end
 
       when :checktype
-        type, = operands
-        raise NotImplementedError if type != 5 # T_STRING
-        # XXX: is_a?
-        env, (val,) = env.pop(1)
-        res = globalize_type(val, env, ep) == Type::Instance.new(Type::Builtin[:str])
-        if res
-          ty = Type::Instance.new(Type::Builtin[:true])
+        kind, = operands
+        case kind
+        when 5 then klass = :str  # T_STRING
+        when 7 then klass = :ary  # T_ARRAY
+        when 8 then klass = :hash # T_HASH
         else
-          ty = Type::Instance.new(Type::Builtin[:false])
+          raise NotImplementedError
+        end
+        env, (val,) = env.pop(1)
+        ty = Type.bot
+        val.each_child do |val|
+        #globalize_type(val, env, ep).each_child_global do |val|
+          val = val.base_type while val.respond_to?(:base_type)
+          case val
+          when Type::Instance.new(Type::Builtin[klass])
+            ty = ty.union(Type::Instance.new(Type::Builtin[:true]))
+          when Type.any
+            ty = Type.bool
+          else
+            ty = ty.union(Type::Instance.new(Type::Builtin[:false]))
+          end
         end
         env = env.push(ty)
       else
@@ -1946,7 +1985,7 @@ module TypeProf
             end
           end
 
-          @block_to_ctx[blk.block_body].each do |blk_ctx|
+          @block_to_ctx[blk.block_body]&.each do |blk_ctx|
             ret_ty = ret_ty.union(@return_values[blk_ctx]) if @return_values[blk_ctx]
           end
         end

data/lib/typeprof/arguments.rb

@@ -25,7 +25,7 @@ module TypeProf
       self
     end
 
-    def consistent_with_method_signature?(msig, subst)
+    def consistent_with_method_signature?(msig)
       aargs = @lead_tys.dup
 
       # aargs: lead_tys, rest_ty
@@ -36,53 +36,61 @@ module TypeProf
         (lower_bound..upper_bound).each do |n|
           # BUG: @rest_ty is an Array, so need to squash
           tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_tys, @blk_ty)
-          if tmp_aargs.consistent_with_method_signature?(msig, subst) # XXX: wrong subst handling in the loop!
-            return true
-          end
+          subst = tmp_aargs.consistent_with_method_signature?(msig) # XXX: wrong subst handling in the loop!
+          return subst if subst
         end
-        return false
+        return nil
       end
 
+      subst = {}
       if msig.rest_ty
-        return false if aargs.size < msig.lead_tys.size + msig.post_tys.size
+        return nil if aargs.size < msig.lead_tys.size + msig.post_tys.size
         aargs.shift(msig.lead_tys.size).zip(msig.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.pop(msig.post_tys.size).zip(msig.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         msig.opt_tys.each do |farg|
           aarg = aargs.shift
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.each do |aarg|
-          return false unless aarg.consistent?(msig.rest_ty, subst)
+          return nil unless subst2 = Type.match?(aarg, msig.rest_ty)
+          subst = Type.merge_substitution(subst, subst2)
         end
       else
-        return false if aargs.size < msig.lead_tys.size + msig.post_tys.size
-        return false if aargs.size > msig.lead_tys.size + msig.post_tys.size + msig.opt_tys.size
+        return nil if aargs.size < msig.lead_tys.size + msig.post_tys.size
+        return nil if aargs.size > msig.lead_tys.size + msig.post_tys.size + msig.opt_tys.size
         aargs.shift(msig.lead_tys.size).zip(msig.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.pop(msig.post_tys.size).zip(msig.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.zip(msig.opt_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
       end
       # XXX: msig.keyword_tys
 
       case msig.blk_ty
       when Type::Proc
-        return false if @blk_ty == Type.nil
+        return nil if @blk_ty == Type.nil
       when Type.nil
-        return false if @blk_ty != Type.nil
+        return nil if @blk_ty != Type.nil
       when Type::Any
       else
         raise "unknown type of formal block signature"
       end
-      true
+
+      subst
     end
 
     def argument_error(given, exp_lower, exp_upper)
@@ -345,7 +353,7 @@ module TypeProf
           when kw.size == 2 # optional keyword (default value is a literal)
             key, default_ty = *kw
             default_ty = Type.guess_literal_type(default_ty)
-            default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
+            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
             req = false
           else # optional keyword (default value is an expression)
             key, = kw

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|
@@ -520,6 +525,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/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)
@@ -318,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)
@@ -476,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
@@ -506,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
@@ -513,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
@@ -539,7 +552,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 +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
-          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)
@@ -635,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
@@ -657,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)
@@ -706,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
@@ -763,7 +773,7 @@ module TypeProf
       end
     end
 
-    class LocalHash < Type
+    class LocalHash < ContainerType
       def initialize(id, base_type)
         @id = id
         @base_type = base_type
@@ -791,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
@@ -798,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