typeprof 0.2.0 → 0.5.0

data/lib/typeprof/iseq.rb

@@ -32,6 +32,23 @@ module TypeProf
         @name, @path, @absolute_path, @start_lineno, @type,
         @locals, @fargs_format, catch_table, insns = *iseq
 
+      case @type
+      when :method, :block
+        if @fargs_format[:opt]
+          label = @fargs_format[:opt].last
+          i = insns.index(label) + 1
+        else
+          i = insns.find_index {|insn| insn.is_a?(Array) }
+        end
+        # skip keyword initialization
+        while insns[i][0] == :checkkeyword
+          raise if insns[i + 1][0] != :branchif
+          label = insns[i + 1][1]
+          i = insns.index(label) + 1
+        end
+        insns[i, 0] = [[:_iseq_body_start]]
+      end
+
       @insns = []
       @linenos = []
 
@@ -79,7 +96,7 @@ module TypeProf
           nil
         when Array
           insn, *operands = e
-          operands = INSN_TABLE[insn].zip(operands).map do |type, operand|
+          operands = (INSN_TABLE[insn] || []).zip(operands).map do |type, operand|
             case type
             when "ISEQ"
               operand && ISeq.new(operand)
@@ -200,6 +217,30 @@ module TypeProf
         @insns[j + 1] = [:send_branch, [getlocal_operands, send_operands, branch_operands]]
       end
 
+      # find a pattern: getlocal, dup, branch
+      (@insns.size - 2).times do |i|
+        next if branch_targets[i + 1] || branch_targets[i + 2]
+        insn0, getlocal_operands = @insns[i]
+        insn1, dup_operands = @insns[i + 1]
+        insn2, branch_operands = @insns[i + 2]
+        if insn0 == :getlocal && insn1 == :dup && insn2 == :branch && getlocal_operands[1] == 0
+          @insns[i    ] = [:nop]
+          @insns[i + 1] = [:nop]
+          @insns[i + 2] = [:getlocal_dup_branch, [getlocal_operands, dup_operands, branch_operands]]
+        end
+      end
+
+      # find a pattern: dup, branch
+      (@insns.size - 1).times do |i|
+        next if branch_targets[i + 1]
+        insn0, dup_operands = @insns[i]
+        insn1, branch_operands = @insns[i + 1]
+        if insn0 == :dup && insn1 == :branch
+          @insns[i    ] = [:nop]
+          @insns[i + 1] = [:dup_branch, [dup_operands, branch_operands]]
+        end
+      end
+
       # find a pattern: getlocal, branch
       (@insns.size - 1).times do |i|
         next if branch_targets[i + 1]

data/lib/typeprof/method.rb

@@ -11,101 +11,121 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
-      aargs.each_formal_arguments(@iseq.fargs_format) do |fargs, start_pc|
-        if fargs.is_a?(String)
-          scratch.error(caller_ep, fargs)
-          ctn[Type.any, caller_ep, caller_env]
-          next
-        end
+      locals = [Type.nil] * @iseq.locals.size
+
+      blk_ty, start_pcs = aargs.setup_formal_arguments(:method, locals, @iseq.fargs_format)
+      if blk_ty.is_a?(String)
+        scratch.error(caller_ep, blk_ty)
+        ctn[Type.any, caller_ep, caller_env]
+        return
+      end
 
-        callee_ep = do_send_core(fargs, start_pc, recv, mid, scratch)
+      nctx = Context.new(@iseq, @cref, mid)
+      callee_ep = ExecutionPoint.new(nctx, 0, nil)
+      nenv = Env.new(StaticEnv.new(recv, blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      alloc_site = AllocationSite.new(callee_ep)
+      locals.each_with_index do |ty, i|
+        alloc_site2 = alloc_site.add_id(i)
+        # nenv is top-level, so it is okay to call Type#localize directly
+        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv = nenv.local_update(i, ty)
+      end
 
-        scratch.add_iseq_method_call!(self, callee_ep.ctx)
-        scratch.add_callsite!(callee_ep.ctx, fargs, caller_ep, caller_env, &ctn)
+      start_pcs.each do |start_pc|
+        scratch.merge_env(ExecutionPoint.new(nctx, start_pc, @outer_ep), nenv)
       end
+
+      scratch.add_iseq_method_call!(self, nctx)
+      scratch.add_callsite!(nctx, caller_ep, caller_env, &ctn)
     end
 
-    def do_send_core(fargs, start_pc, recv, mid, scratch)
+    def do_check_send(msig, recv, mid, ep, scratch)
+      lead_num = @iseq.fargs_format[:lead_num] || 0
+      post_num = @iseq.fargs_format[:post_num] || 0
+      rest_start = @iseq.fargs_format[:rest_start]
+      opt = @iseq.fargs_format[:opt] || [0]
+
+      # TODO: check keywords
+      if rest_start
+        # almost ok
+      else
+        if msig.lead_tys.size + msig.post_tys.size < lead_num + post_num
+          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at least %d arguments" % [msig.lead_tys.size + msig.post_tys.size, lead_num + post_num])
+          return
+        end
+        if msig.lead_tys.size + msig.opt_tys.size + msig.post_tys.size > lead_num + opt.size - 1 + post_num
+          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at most %d arguments" % [msig.lead_tys.size + msig.opt_tys.size + msig.post_tys.size, lead_num + opt.size - 1 + post_num])
+          return
+        end
+      end
+
       lead_num = @iseq.fargs_format[:lead_num] || 0
       post_start = @iseq.fargs_format[:post_start]
       rest_start = @iseq.fargs_format[:rest_start]
       kw_start = @iseq.fargs_format[:kwbits]
       kw_start -= @iseq.fargs_format[:keyword].size if kw_start
+      kw_rest = @iseq.fargs_format[:kwrest]
       block_start = @iseq.fargs_format[:block_start]
 
-      # XXX: need to check .rbs fargs and .rb fargs
+      # XXX: need to check .rbs msig and .rb fargs
 
       ctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(ctx, start_pc, nil)
+      callee_ep = ExecutionPoint.new(ctx, 0, nil)
 
       locals = [Type.nil] * @iseq.locals.size
-      nenv = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       idx = 0
-      fargs.lead_tys.each_with_index do |ty, i|
+      msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
         # nenv is top-level, so it is okay to call Type#localize directly
         nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(i, ty)
       end
-      if fargs.opt_tys
-        fargs.opt_tys.each_with_index do |ty, i|
+      if msig.opt_tys
+        msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(lead_num + i, ty)
         end
       end
-      if fargs.rest_ty
+      if msig.rest_ty
         alloc_site2 = alloc_site.add_id(idx += 1)
-        ty = Type::Array.new(Type::Array::Elements.new([], fargs.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
+        ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
         nenv, rest_ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(rest_start, rest_ty)
       end
-      if fargs.post_tys
-        fargs.post_tys.each_with_index do |ty, i|
+      if msig.post_tys
+        msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
-      if fargs.kw_tys
-        fargs.kw_tys.each_with_index do |(_, _, ty), i|
-          alloc_site2 = alloc_site.add_id(idx += 1)
+      if msig.kw_tys
+        msig.kw_tys.each_with_index do |(_, key, ty), i|
+          alloc_site2 = alloc_site.add_id(key)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
-      # kwrest
-      nenv = nenv.local_update(block_start, fargs.blk_ty) if block_start
-
-      scratch.merge_env(callee_ep, nenv)
-
-      callee_ep
-    end
-
-    def do_check_send_core(fargs, recv, mid, ep, scratch)
-      lead_num = @iseq.fargs_format[:lead_num] || 0
-      post_num = @iseq.fargs_format[:post_num] || 0
-      rest_start = @iseq.fargs_format[:rest_start]
-      opt = @iseq.fargs_format[:opt] || [0]
+      if msig.kw_rest_ty
+        ty = msig.kw_rest_ty
+        alloc_site2 = alloc_site.add_id(:**)
+        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv = nenv.local_update(kw_rest, ty)
+      end
+      nenv = nenv.local_update(block_start, msig.blk_ty) if block_start
 
-      # TODO: check keywords
-      if rest_start
-        # almost ok
-      else
-        if fargs.lead_tys.size + fargs.post_tys.size < lead_num + post_num
-          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at least %d arguments" % [fargs.lead_tys.size + fargs.post_tys.size, lead_num + post_num])
-          return
-        end
-        if fargs.lead_tys.size + fargs.opt_tys.size + fargs.post_tys.size > lead_num + opt.size - 1 + post_num
-          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at most %d arguments" % [fargs.lead_tys.size + fargs.opt_tys.size + fargs.post_tys.size, lead_num + opt.size - 1 + post_num])
-          return
-        end
+      opt.each do |start_pc|
+        scratch.merge_env(ExecutionPoint.new(ctx, start_pc, nil), nenv)
       end
-      do_send_core(fargs, 0, recv, mid, scratch)
+
+      ctx
     end
   end
 
@@ -141,8 +161,8 @@ module TypeProf
   end
 
   class TypedMethodDef < MethodDef
-    def initialize(sigs, rbs_source) # sigs: Array<[FormalArguments, (return)Type]>
-      @sigs = sigs
+    def initialize(sig_rets, rbs_source) # sig_rets: Array<[MethodSignature, (return)Type]>
+      @sig_rets = sig_rets
       @rbs_source = rbs_source
     end
 
@@ -152,45 +172,78 @@ module TypeProf
       recv = scratch.globalize_type(recv_orig, caller_env, caller_ep)
       found = false
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
-      @sigs.each do |fargs, ret_ty|
+      @sig_rets.each do |msig, ret_ty|
         ncaller_env = caller_env
-        #pp [mid, aargs, fargs]
-        # XXX: support self type in fargs
-        subst = { Type::Var.new(:self) => recv }
-        next unless aargs.consistent_with_formal_arguments?(fargs, subst)
-        if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+        #pp [mid, aargs, msig]
+        # XXX: support self type in msig
+        subst = aargs.consistent_with_method_signature?(msig)
+        next unless subst
+        # need to check self tyvar?
+        subst[Type::Var.new(:self)] = recv
+        case
+        when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
+          tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+          tyvars.each_with_index do |tyvar, idx|
+            ty = subst[tyvar]
+            if ty
+              ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                elems.update(idx, ty)
+              end
+            end
+          end
+          tyvars.zip(recv.elems.elems) do |tyvar, elem|
+            if subst[tyvar]
+              subst[tyvar] = subst[tyvar].union(elem)
+            else
+              subst[tyvar] = elem
+            end
+          end
+        when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
           tyvar_elem = Type::Var.new(:Elem)
           if subst[tyvar_elem]
             ty = subst[tyvar_elem]
-            alloc_site = AllocationSite.new(caller_ep).add_id(self)
             ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
+            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
               elems.update(nil, ty)
             end
           end
           subst.merge!({ tyvar_elem => recv.elems.squash })
-        elsif recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+        when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
           tyvar_k = Type::Var.new(:K)
           tyvar_v = Type::Var.new(:V)
-          # XXX: need to support destructive operation
-          k_ty, v_ty = recv.elems.squash
+          k_ty0, v_ty0 = recv.elems.squash
+          if subst[tyvar_k] && subst[tyvar_v]
+            k_ty = subst[tyvar_k]
+            v_ty = subst[tyvar_v]
+            k_ty0 = k_ty0.union(k_ty)
+            v_ty0 = v_ty0.union(v_ty)
+            alloc_site = AllocationSite.new(caller_ep)
+            ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
+            ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
+            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+              elems.update(k_ty, v_ty)
+            end
+          end
           # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
-          subst.merge!({ tyvar_k => k_ty, tyvar_v => v_ty })
+          subst.merge!({ tyvar_k => k_ty0, tyvar_v => v_ty0 })
         end
-        ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
         found = true
-        if aargs.blk_ty.is_a?(Type::ISeqProc)
+        if aargs.blk_ty.is_a?(Type::Proc)
+          #raise NotImplementedError unless aargs.blk_ty.block_body.is_a?(ISeqBlock) # XXX
           dummy_ctx = TypedContext.new(caller_ep, mid)
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
-          dummy_env = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), [], [], Utils::HashWrapper.new({}))
-          if fargs.blk_ty.is_a?(Type::TypedProc)
-            scratch.add_callsite!(dummy_ctx, nil, caller_ep, ncaller_env, &ctn)
-            nfargs = fargs.blk_ty.fargs
+          s_recv = recv
+          s_recv = s_recv.base_type while s_recv.respond_to?(:base_type)
+          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
+          if msig.blk_ty.is_a?(Type::Proc)
+            scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
+            nfargs = msig.blk_ty.block_body.msig
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
             nlead_tys = (nfargs.lead_tys + nfargs.opt_tys).map.with_index do |ty, i|
               if recv.is_a?(Type::Array)
                 tyvar_elem = Type::Var.new(:Elem)
-                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash }), Config.options[:type_depth_limit])
+                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash_or_any }), Config.options[:type_depth_limit])
               else
                 ty = ty.substitute(subst, Config.options[:type_depth_limit])
               end
@@ -200,15 +253,57 @@ module TypeProf
               ty
             end
             0.upto(nfargs.opt_tys.size) do |n|
-              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, nil, Type.nil) # XXX: support block to block?
-              scratch.do_invoke_block(false, aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
-                subst2 = {}
-                if blk_ret_ty.consistent?(fargs.blk_ty.ret_ty, subst2)
-                  if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
+              scratch.do_invoke_block(aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
+                subst2 = Type.match?(blk_ret_ty, msig.blk_ty.block_body.ret_ty)
+                if subst2
+                  subst2 = Type.merge_substitution(subst, subst2)
+                  case
+                  when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
+                    tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+                    tyvars.each_with_index do |tyvar, idx|
+                      ty = subst2[tyvar]
+                      if ty
+                        ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+                        ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                          elems.update(idx, ty)
+                        end
+                        scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                      end
+                    end
+                    tyvars.zip(recv.elems.elems) do |tyvar, elem|
+                      if subst2[tyvar]
+                        subst2[tyvar] = subst2[tyvar].union(elem)
+                      else
+                        subst2[tyvar] = elem
+                      end
+                    end
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
                     tyvar_elem = Type::Var.new(:Elem)
                     if subst2[tyvar_elem]
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
-                        elems.update(nil, subst2[tyvar_elem])
+                      ty = subst2[tyvar_elem]
+                      ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                        elems.update(nil, ty)
+                      end
+                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                    end
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+                    tyvar_k = Type::Var.new(:K)
+                    tyvar_v = Type::Var.new(:V)
+                    k_ty0, v_ty0 = recv.elems.squash
+                    if subst2[tyvar_k] && subst2[tyvar_v]
+                      k_ty = subst2[tyvar_k]
+                      v_ty = subst2[tyvar_v]
+                      k_ty0 = k_ty0.union(k_ty)
+                      v_ty0 = v_ty0.union(v_ty)
+                      alloc_site = AllocationSite.new(caller_ep)
+                      ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
+                      ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
+                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                        elems.update(k_ty, v_ty)
                       end
                       scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                     end
@@ -223,10 +318,10 @@ module TypeProf
                 end
                 ret_ty = ret_ty.remove_type_vars
                 # XXX: check the return type from the block
-                # sig.blk_ty.ret_ty.eql?(_ret_ty) ???
-                scratch.add_return_type!(dummy_ctx, ret_ty)
+                # sig.blk_ty.block_body.ret_ty.eql?(_ret_ty) ???
+                scratch.add_return_value!(dummy_ctx, ret_ty)
               end
-              # scratch.add_return_type!(dummy_ctx, ret_ty) ?
+              # scratch.add_return_value!(dummy_ctx, ret_ty) ?
               # This makes `def foo; 1.times { return "str" }; end` return Integer|String
             end
           else
@@ -236,6 +331,7 @@ module TypeProf
             ctn[ret_ty, caller_ep, ncaller_env]
           end
         else
+          ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
           ret_ty = ret_ty.remove_type_vars
           ctn[ret_ty, caller_ep, ncaller_env]
         end
@@ -249,8 +345,8 @@ module TypeProf
 
     def do_match_iseq_mdef(iseq_mdef, recv, mid, env, ep, scratch)
       recv = scratch.globalize_type(recv, env, ep)
-      @sigs.each do |fargs, _ret_ty|
-        iseq_mdef.do_check_send_core(fargs, recv, mid, ep, scratch)
+      @sig_rets.each do |msig, _ret_ty|
+        iseq_mdef.do_check_send(msig, recv, mid, ep, scratch)
       end
     end
   end

data/lib/typeprof/type.rb

@@ -3,7 +3,7 @@ module TypeProf
     include Utils::StructuralEquality
 
     def initialize
-      raise "cannot instanciate abstract type"
+      raise "cannot instantiate abstract type"
     end
 
     Builtin = {}
@@ -20,16 +20,69 @@ module TypeProf
       self
     end
 
-    def consistent?(other, subst)
-      case other
-      when Type::Any then true
-      when Type::Var then other.add_subst!(self, subst)
+    def self.match?(ty1, ty2)
+      # both ty1 and ty2 should be global
+      # ty1 is always concrete; it should not have type variables
+      # ty2 might be abstract; it may have type variables
+      case ty2
+      when Type::Var
+        { ty2 => ty1 }
+      when Type::Any
+        {}
       when Type::Union
-        other.types.each do |ty2|
-          return true if consistent?(ty2, subst)
+        subst = nil
+        ty2.each_child_global do |ty2|
+          # this is very conservative to create subst:
+          # Type.match?( int | str, int | X) creates { X => int | str } but should be { X => str }???
+          subst2 = Type.match?(ty1, ty2)
+          next unless subst2
+          subst = Type.merge_substitution(subst, subst2)
         end
+        subst
       else
-        self == other
+        case ty1
+        when Type::Var then raise "should not occur"
+        when Type::Any
+          subst = {}
+          ty2.each_free_type_variable do |tyvar|
+            subst[tyvar] = Type.any
+          end
+          subst
+        when Type::Union
+          subst = nil
+          ty1.each_child_global do |ty1|
+            subst2 = Type.match?(ty1, ty2)
+            next unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        else
+          if ty2.is_a?(Type::ContainerType)
+            # ty2 may have type variables
+            return nil if ty1.class != ty2.class
+            ty1.match?(ty2)
+          elsif ty1.is_a?(Type::ContainerType)
+            nil
+          else
+            ty1.consistent?(ty2) ? {} : nil
+          end
+        end
+      end
+    end
+
+    def self.merge_substitution(subst1, subst2)
+      if subst1
+        subst1 = subst1.dup
+        subst2.each do |tyvar, ty|
+          if subst1[tyvar]
+            subst1[tyvar] = subst1[tyvar].union(ty)
+          else
+            subst1[tyvar] = ty
+          end
+        end
+        subst1
+      else
+        subst2
       end
     end
 
@@ -41,6 +94,9 @@ module TypeProf
       yield self
     end
 
+    def each_free_type_variable
+    end
+
     def union(other)
       return self if self == other # fastpath
 
@@ -118,10 +174,8 @@ module TypeProf
         nil
       end
 
-      def consistent?(other, subst)
-        # need to create a type assignment if other is Var
-        other.add_subst!(self, subst) if other.is_a?(Type::Var)
-        true
+      def consistent?(_other)
+        raise "should not be called"
       end
 
       def substitute(_subst, _depth)
@@ -129,6 +183,17 @@ module TypeProf
       end
     end
 
+    class Void < Any
+      def inspect
+        "Type::Void"
+      end
+
+      def screen_name(scratch)
+        "void"
+      end
+    end
+
+
     class Union < Type
       def initialize(tys, elems)
         raise unless tys.is_a?(Utils::Set)
@@ -137,7 +202,7 @@ module TypeProf
         # invariant check
         local = nil
         tys.each do |ty|
-          raise unless ty.is_a?(Type)
+          raise ty.inspect unless ty.is_a?(Type)
           local = true if ty.is_a?(LocalArray) || ty.is_a?(LocalHash)
         end
         raise if local && elems
@@ -145,6 +210,12 @@ module TypeProf
         @elems = elems
       end
 
+      def each_free_type_variable(&blk)
+        each_child_global do |ty|
+          ty.each_free_type_variable(&blk)
+        end
+      end
+
       def limit_size(limit)
         return Type.any if limit <= 0
         tys = Utils::Set[]
@@ -215,12 +286,15 @@ module TypeProf
             bool = true
           end
           types.delete(Type.any) unless Config.options[:pedantic_output]
+          proc_tys, types = types.partition {|ty| ty.is_a?(Proc) }
           types = types.map {|ty| ty.screen_name(scratch) }
+          types << scratch.show_proc_signature(proc_tys) unless proc_tys.empty?
           types << "bool" if bool
           types = types.sort
           if optional
-            if types.size == 1
-              types.first + "?"
+            case types.size
+            when 0 then "nil"
+            when 1 then types.first + "?"
             else
               "(#{ types.join (" | ") })?"
             end
@@ -257,48 +331,20 @@ module TypeProf
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
         tys = @types.map do |ty|
-          alloc_site2 = alloc_site.add_id(ty)
-          env, ty2 = ty.localize(env, alloc_site2, depth - 1)
+          env, ty2 = ty.localize(env, alloc_site, depth - 1)
           ty2
         end
         @elems&.each do |(container_kind, base_type), elems|
           ty = container_kind.new(elems, base_type)
-          alloc_site2 = alloc_site.add_id(container_kind.name.to_sym).add_id(base_type)
-          env, ty = ty.localize(env, alloc_site2, depth - 1)
+          env, ty = ty.localize(env, alloc_site, depth - 1)
           tys = tys.add(ty)
         end
         ty = Union.new(tys, nil).normalize
         return env, ty
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          # this is very conservative to create subst:
-          # consistent?( int | str, int | X) creates { X => int | str } but should be { X => str }???
-          @types.each do |ty1|
-            other.types.each do |ty2|
-              subst2 = subst.dup
-              if ty1.consistent?(ty2, subst2)
-                subst.replace(subst2)
-                # XXX: need to check other pairs to create conservative substitution??
-                # consistent?( X | :foo, str | int ) may return { X => str } or { X => int } but should be { X => str | int }?
-                return true
-              end
-            end
-          end
-          return true if @types.size == 0 && other.types.size == 0 # XXX: is this okay?
-          # TODO: array argument?
-          return false
-        else
-          @types.each do |ty1|
-            return true if ty1.consistent?(other, subst)
-          end
-          # TODO: array argument?
-          return false
-        end
+      def consistent?(_other)
+        raise "should not be called"
       end
 
       def substitute(subst, depth)
@@ -317,7 +363,7 @@ module TypeProf
         elems = @elems&.to_h do |(container_kind, base_type), elems|
           [[container_kind, base_type], elems.substitute(subst, depth - 1)]
         end
-        ty = Union.new(tys, elems)
+        ty = Union.new(tys, elems).normalize
         unions.each do |ty0|
           ty = ty.union(ty0)
         end
@@ -357,6 +403,10 @@ module TypeProf
         "Var[#{ @name }]"
       end
 
+      def each_free_type_variable
+        yield self
+      end
+
       def substitute(subst, depth)
         if subst[self]
           subst[self].limit_size(depth)
@@ -365,7 +415,7 @@ module TypeProf
         end
       end
 
-      def consistent?(other, subst)
+      def consistent?(_other)
         raise "should not be called: #{ self }"
       end
 
@@ -406,15 +456,8 @@ module TypeProf
         scratch.get_method(self, true, mid)
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty|
-            return true if consistent?(ty, subst)
-          end
-          return false
         when Type::Class
           ty = self
           loop do
@@ -465,17 +508,10 @@ module TypeProf
         scratch.get_method(@klass, false, mid)
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty|
-            return true if consistent?(ty, subst)
-          end
-          return false
         when Type::Instance
-          @klass.consistent?(other.klass, subst)
+          @klass.consistent?(other.klass)
         when Type::Class
           return true if @klass == Type::Builtin[:obj] || @klass == Type::Builtin[:class] || @klass == Type::Builtin[:module]
           return false
@@ -489,6 +525,7 @@ module TypeProf
       end
     end
 
+    # This is an internal object in MRI, so a user program cannot create this object explicitly
     class ISeq < Type
       def initialize(iseq)
         @iseq = iseq
@@ -505,66 +542,53 @@ module TypeProf
       end
     end
 
-    class ISeqProc < Type
-      def initialize(iseq, ep, type)
-        @iseq = iseq
-        @ep = ep
-        @type = type
+    class Proc < Type
+      def initialize(block_body, base_type)
+        @block_body, @base_type = block_body, base_type
       end
 
-      attr_reader :iseq, :ep, :type
-
-      def inspect
-        "#<ISeqProc>"
-      end
+      attr_reader :block_body, :base_type
 
-      def screen_name(scratch)
-        "Proc[#{ scratch.proc_screen_name(self) }]" # TODO: use RBS syntax
+      def consistent?(other)
+        case other
+        when Type::Proc
+          @block_body.consistent?(other.block_body)
+        else
+          self == other
+        end
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
-      def substitute(_subst, _depth)
-        self # XXX
-      end
-    end
-
-    class TypedProc < Type
-      def initialize(fargs, ret_ty, type)
-        @fargs = fargs
-        @ret_ty = ret_ty
-        @type = type
+      def substitute(subst, depth)
+        Proc.new(@block_body.substitute(subst, depth), @base_type)
       end
 
-      attr_reader :fargs, :ret_ty
-
       def screen_name(scratch)
-        "TypedProc[...]" # TODO: use RBS syntax
+        scratch.show_proc_signature([self])
       end
     end
 
     class Symbol < Type
-      def initialize(sym, type)
+      def initialize(sym, base_type)
         @sym = sym
-        @type = type
+        @base_type = base_type
       end
 
-      attr_reader :sym, :type
+      attr_reader :sym, :base_type
 
       def inspect
-        "Type::Symbol[#{ @sym ? @sym.inspect : "(dynamic symbol)" }, #{ @type.inspect }]"
+        "Type::Symbol[#{ @sym ? @sym.inspect : "(dynamic symbol)" }, #{ @base_type.inspect }]"
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Var
-          other.add_subst!(self, subst)
         when Symbol
           @sym == other.sym
         else
-          @type.consistent?(other, subst)
+          @base_type.consistent?(other)
         end
       end
 
@@ -572,12 +596,12 @@ module TypeProf
         if @sym
           @sym.inspect
         else
-          @type.screen_name(scratch)
+          @base_type.screen_name(scratch)
         end
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
       def substitute(_subst, _depth)
@@ -585,33 +609,33 @@ module TypeProf
       end
     end
 
-    # local info
+    # A local type
     class Literal < Type
-      def initialize(lit, type)
+      def initialize(lit, base_type)
         @lit = lit
-        @type = type
+        @base_type = base_type
       end
 
-      attr_reader :lit, :type
+      attr_reader :lit, :base_type
 
       def inspect
-        "Type::Literal[#{ @lit.inspect }, #{ @type.inspect }]"
+        "Type::Literal[#{ @lit.inspect }, #{ @base_type.inspect }]"
       end
 
       def screen_name(scratch)
-        @type.screen_name(scratch) + "<#{ @lit.inspect }>"
+        @base_type.screen_name(scratch) + "<#{ @lit.inspect }>"
       end
 
       def globalize(_env, _visited, _depth)
-        @type
+        @base_type
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
-      def consistent?(other, subst)
-        @type.consistent?(other, subst)
+      def consistent?(_other)
+        raise "should not called"
       end
     end
 
@@ -736,66 +760,74 @@ module TypeProf
     end
   end
 
-  # Arguments for callee side
-  class FormalArguments
+  class Signature
     include Utils::StructuralEquality
 
-    def initialize(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
-      @lead_tys = lead_tys
-      @opt_tys = opt_tys
-      @rest_ty = rest_ty
-      @post_tys = post_tys
-      @kw_tys = kw_tys
-      kw_tys.each {|a| raise if a.size != 3 } if kw_tys
-      @kw_rest_ty = kw_rest_ty
-      @blk_ty = blk_ty
-    end
-
-    attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
-
-    def consistent?(fargs, subst)
-      warn "used?"
-      return false if @lead_tys.size != fargs.lead_tys.size
-      return false unless @lead_tys.zip(fargs.lead_tys).all? {|ty1, ty2| ty1.consistent?(ty2, subst) }
-      return false if (@opt_tys || []) != (fargs.opt_tys || []) # ??
-      if @rest_ty
-        return false unless @rest_ty.consistent?(fargs.rest_ty, subst)
-      end
-      if @post_tys
-        return false if @post_tys.size != fargs.post_tys.size
-        return false unless @post_tys.zip(fargs.post_tys).all? {|ty1, ty2| ty1.consistent?(ty2, subst) }
-      end
-      return false if @kw_tys.size != fargs.kw_tys.size
-      return false unless @kw_tys.zip(fargs.kw_tys).all? {|(_, ty1), (_, ty2)| ty1.consistent?(ty2, subst) }
-      if @kw_rest_ty
-        return false unless @kw_rest_ty.consistent?(fargs.kw_rest_ty, subst)
-      end
-      # intentionally skip blk_ty
-      true
-    end
-
     def screen_name(scratch)
-      fargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
+      str = @lead_tys.map {|ty| ty.screen_name(scratch) }
       if @opt_tys
-        fargs += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        str += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
       end
       if @rest_ty
-        fargs << ("*" + @rest_ty.screen_name(scratch))
+        str << ("*" + @rest_ty.screen_name(scratch))
       end
       if @post_tys
-        fargs += @post_tys.map {|ty| ty.screen_name(scratch) }
+        str += @post_tys.map {|ty| ty.screen_name(scratch) }
       end
       if @kw_tys
         @kw_tys.each do |req, sym, ty|
           opt = req ? "" : "?"
-          fargs << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
+          str << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
         end
       end
       if @kw_rest_ty
-        fargs << ("**" + @kw_rest_ty.screen_name(scratch))
+        str << ("**" + @kw_rest_ty.screen_name(scratch))
+      end
+      str = str.empty? ? "" : "(#{ str.join(", ") })"
+
+      optional = false
+      blks = []
+      @blk_ty.each_child_global do |ty|
+        if ty.is_a?(Type::Proc)
+          blks << ty
+        else
+          # XXX: how should we handle types other than Type.nil
+          optional = true
+        end
       end
-      # intentionally skip blk_ty
-      fargs
+      if blks != []
+        str << " " if str != ""
+        str << "?" if optional
+        str << scratch.show_block_signature(blks)
+      end
+
+      str
+    end
+  end
+
+  class MethodSignature < Signature
+    def initialize(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
+      @lead_tys = lead_tys
+      @opt_tys = opt_tys
+      @rest_ty = rest_ty
+      @post_tys = post_tys
+      @kw_tys = kw_tys
+      kw_tys.each {|a| raise if a.size != 3 } if kw_tys
+      @kw_rest_ty = kw_rest_ty
+      @blk_ty = blk_ty
+    end
+
+    attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
+
+    def substitute(subst, depth)
+      lead_tys = @lead_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      opt_tys = @opt_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      rest_ty = @rest_ty&.substitute(subst, depth - 1)
+      post_tys = @post_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      kw_tys = @kw_tys.map {|req, key, ty| [req, key, ty.substitute(subst, depth - 1)] }
+      kw_rest_ty = @kw_rest_ty&.substitute(subst, depth - 1)
+      blk_ty = @blk_ty.substitute(subst, depth - 1)
+      MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
 
     def merge(other)
@@ -810,8 +842,6 @@ module TypeProf
           raise if !!kws1[kw] != !!kws2[kw]
         end
       elsif @kw_tys || other.kw_tys
-        puts
-        p self, other
         (@kw_tys || other.kw_tys).each do |req,|
           raise if req
         end
@@ -859,231 +889,60 @@ module TypeProf
         end
       end
       blk_ty = @blk_ty.union(other.blk_ty) if @blk_ty
-      FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
+      MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
   end
 
-  # Arguments from caller side
-  class ActualArguments
-    def initialize(lead_tys, rest_ty, kw_ty, blk_ty)
+  class BlockSignature < Signature
+    def initialize(lead_tys, opt_tys, rest_ty, blk_ty)
       @lead_tys = lead_tys
+      @opt_tys = opt_tys
       @rest_ty = rest_ty
-      @kw_ty = kw_ty
       @blk_ty = blk_ty
-      raise unless blk_ty
-    end
-
-    attr_reader :lead_tys, :rest_ty, :kw_ty, :blk_ty
-
-    def merge(aargs)
-      len = [@lead_tys.size, aargs.lead_tys.size].min
-      lead_tys = @lead_tys[0, len].zip(aargs.lead_tys[0, len]).map do |ty1, ty2|
-        ty1.union(ty2)
-      end
-      rest_ty = @rest_ty || Type.bot
-      rest_ty = rest_ty.union(aargs.rest_ty) if aargs.rest_ty
-      (@lead_tys[len..] + aargs.lead_tys[len..]).each do |ty|
-        rest_ty = rest_ty.union(ty)
-      end
-      rest_ty = nil if rest_ty == Type.bot
-      #kw_ty = @kw_ty.union(aargs.kw_ty) # TODO
-      blk_ty = @blk_ty.union(aargs.blk_ty)
-      ActualArguments.new(lead_tys, rest_ty, kw_ty, blk_ty)
-    end
-
-    def globalize(caller_env, visited, depth)
-      lead_tys = @lead_tys.map {|ty| ty.globalize(caller_env, visited, depth) }
-      rest_ty = @rest_ty.globalize(caller_env, visited, depth) if @rest_ty
-      kw_ty = @kw_ty.globalize(caller_env, visited, depth) if @kw_ty
-      ActualArguments.new(lead_tys, rest_ty, kw_ty, @blk_ty)
-    end
-
-    def limit_size(limit)
-      self
-    end
-
-    def each_formal_arguments(fargs_format)
-      lead_num = fargs_format[:lead_num] || 0
-      post_num = fargs_format[:post_num] || 0
-      rest_acceptable = !!fargs_format[:rest_start]
-      keyword = fargs_format[:keyword]
-      kw_rest_acceptable = !!fargs_format[:kwrest]
-      opt = fargs_format[:opt]
-      #p fargs_format
-
-      # TODO: expand tuples to normal arguments
-
-      # check number of arguments
-      if !@rest_ty && lead_num + post_num > @lead_tys.size
-        # too less
-        yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-        return
-      end
-      if !rest_acceptable
-        # too many
-        if opt
-          if lead_num + post_num + opt.size - 1 < @lead_tys.size
-            yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num }..#{ lead_num + post_num + opt.size - 1})"
-            return
-          end
-        else
-          if lead_num + post_num < @lead_tys.size
-            yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-            return
+      # TODO: kw_tys
+    end
+
+    attr_reader :lead_tys, :opt_tys, :rest_ty, :blk_ty
+
+    def merge(bsig)
+      if @rest_ty && bsig.rest_ty
+        rest_ty = @rest_ty.union(bsig.rest_ty)
+        BlockSignature.new(@lead_tys, [], rest_ty, @blk_ty.union(bsig.blk_ty))
+      elsif @rest_ty || bsig.rest_ty
+        rest_ty = @rest_ty || bsig.rest_ty
+        rest_ty = @opt_tys.inject(rest_ty, &:union)
+        rest_ty = bsig.opt_tys.inject(rest_ty, &:union)
+
+        lead_tys = []
+        [@lead_tys.size, bsig.lead_tys.size].max.times do |i|
+          ty1 = @lead_tys[i]
+          ty2 = bsig.lead_tys[i]
+          if ty1 && ty2
+            lead_tys << ty1.union(ty2)
+          else
+            rest_ty = rest_ty.union(ty1 || ty2)
           end
         end
-      end
 
-      if @rest_ty
-        lower_bound = [lead_num + post_num - @lead_tys.size, 0].max
-        upper_bound = lead_num + post_num - @lead_tys.size + (opt ? opt.size - 1 : 0) + (rest_acceptable ? 1 : 0)
-        rest_elem = @rest_ty.is_a?(Type::Array) ? @rest_ty.elems.squash : Type.any
+        BlockSignature.new(lead_tys, [], rest_ty, @blk_ty.union(bsig.blk_ty))
       else
-        lower_bound = upper_bound = 0
-      end
-
-      if keyword
-        kw_tys = []
-        keyword.each do |kw|
-          case
-          when kw.is_a?(Symbol) # required keyword
-            key = kw
-            req = true
-          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)
-            req = false
-          else # optional keyword (default value is an expression)
-            key, = kw
-            req = false
-          end
-
-          sym = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
-          ty = Type.bot
-          if @kw_ty.is_a?(Type::Hash)
-            # XXX: consider Union
-            ty = @kw_ty.elems[sym]
-            # XXX: remove the key
-          end
-          if ty == Type.bot
-            yield "no argument for required keywords"
-            return
-          end
-          ty = ty.union(default_ty) if default_ty
-          kw_tys << [req, key, ty]
-        end
-      end
-      if kw_rest_acceptable
-        kw_rest_ty = @kw_ty
-        if kw_rest_ty == Type.any
-          kw_rest_ty = Type.gen_hash {|h| h[Type.any] = Type.any }
-        end
-      end
-      #if @kw_ty
-      #  yield "passed a keyword to non-keyword method"
-      #end
-
-      (lower_bound .. upper_bound).each do |rest_len|
-        aargs = @lead_tys + [rest_elem] * rest_len
-        lead_tys = aargs.shift(lead_num)
-        lead_tys << rest_elem until lead_tys.size == lead_num
-        post_tys = aargs.pop(post_num)
-        post_tys.unshift(rest_elem) until post_tys.size == post_num
-        start_pc = 0
-        if opt
-          tmp_opt = opt[1..]
-          opt_tys = []
-          until aargs.empty? || tmp_opt.empty?
-            opt_tys << aargs.shift
-            start_pc = tmp_opt.shift
-          end
-        end
-        if rest_acceptable
-          acc = aargs.inject {|acc, ty| acc.union(ty) }
-          acc = acc ? acc.union(rest_elem) : rest_elem if rest_elem
-          acc ||= Type.bot
-          rest_ty = acc
-          aargs.clear
-        end
-        if !aargs.empty?
-          yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-          return
+        lead_tys = []
+        n = [@lead_tys.size, bsig.lead_tys.size].min
+        n.times do |i|
+          lead_tys << @lead_tys[i].union(bsig.lead_tys[i])
         end
-        yield FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, @blk_ty), start_pc
-      end
-    end
-
-    def consistent_with_formal_arguments?(fargs, subst)
-      aargs = @lead_tys.dup
-
-      # aargs: lead_tys, rest_ty
-      # fargs: lead_tys, opt_tys, rest_ty, post_tys
-      if @rest_ty
-        lower_bound = [0, fargs.lead_tys.size + fargs.post_tys.size - aargs.size].max
-        upper_bound = [0, lower_bound + fargs.opt_tys.size].max
-        (lower_bound..upper_bound).each do |n|
-          tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_ty, @blk_ty)
-          if tmp_aargs.consistent_with_formal_arguments?(fargs, subst)
-            return true
+        opt_tys1 = @lead_tys[n..] + @opt_tys
+        opt_tys2 = bsig.lead_tys[n..] + bsig.opt_tys
+        opt_tys = []
+        [opt_tys1.size, opt_tys2.size].max.times do |i|
+          if opt_tys1[i] && opt_tys2[i]
+            opt_tys << opt_tys1[i].union(opt_tys2[i])
+          else
+            opt_tys << (opt_tys1[i] || opt_tys2[i])
           end
         end
-        return false
-      end
-
-      if fargs.rest_ty
-        return false if aargs.size < fargs.lead_tys.size + fargs.post_tys.size
-        aargs.shift(fargs.lead_tys.size).zip(fargs.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.pop(fargs.post_tys.size).zip(fargs.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        fargs.opt_tys.each do |farg|
-          aarg = aargs.shift
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.each do |aarg|
-          return false unless aarg.consistent?(fargs.rest_ty, subst)
-        end
-      else
-        return false if aargs.size < fargs.lead_tys.size + fargs.post_tys.size
-        return false if aargs.size > fargs.lead_tys.size + fargs.post_tys.size + fargs.opt_tys.size
-        aargs.shift(fargs.lead_tys.size).zip(fargs.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.pop(fargs.post_tys.size).zip(fargs.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.zip(fargs.opt_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-      end
-      # XXX: fargs.keyword_tys
-
-      case fargs.blk_ty
-      when Type::TypedProc
-        return false if @blk_ty == Type.nil
-      when Type.nil
-        return false if @blk_ty != Type.nil
-      when Type::Any
-      else
-        raise "unknown typo of formal block signature"
-      end
-      true
-    end
-
-    def screen_name(scratch)
-      aargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
-      if @rest_ty
-        aargs << ("*" + @rest_ty.screen_name(scratch))
-      end
-      if @kw_ty
-        aargs << ("**" + @kw_ty.screen_name(scratch)) # TODO: Hash notation -> keyword notation
+        BlockSignature.new(lead_tys, opt_tys, nil, @blk_ty.union(bsig.blk_ty))
       end
-      s = "(#{ aargs.join(", ") })"
-      s << " { #{ scratch.proc_screen_name(@blk_ty) } }" if @blk_ty != Type.nil
-      s
     end
   end
 end