typeprof 0.1.2 → 0.4.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)
@@ -125,7 +142,7 @@ module TypeProf
       "#{ @path }:#{ @linenos[pc] }"
     end
 
-    attr_reader :name, :path, :abolute_path, :start_lineno, :type, :locals, :fargs_format, :catch_table, :insns, :linenos
+    attr_reader :name, :path, :absolute_path, :start_lineno, :type, :locals, :fargs_format, :catch_table, :insns, :linenos
     attr_reader :id
 
     def pretty_print(q)
@@ -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

@@ -14,108 +14,128 @@ module TypeProf
       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
 
-        callee_ep = do_send_core(fargs, start_pc, recv, mid, scratch)
+      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
+
+      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) # XXX: to support opts, rest, etc
-      callee_ep = ExecutionPoint.new(ctx, start_pc, nil)
+      ctx = Context.new(@iseq, @cref, mid)
+      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
 
   class AttrMethodDef < MethodDef
-    def initialize(ivar, kind)
+    def initialize(ivar, kind, absolute_path)
       @ivar = ivar
       @kind = kind # :reader | :writer
+      @absolute_path = absolute_path
     end
 
-    attr_reader :ivar, :kind
+    attr_reader :ivar, :kind, :absolute_path
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       case @kind
@@ -140,8 +160,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
 
@@ -151,25 +171,42 @@ 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
-        # XXX: need to interpret args more correctly
-        #pp [mid, aargs, fargs]
-        # XXX: support self type in fargs
+        #pp [mid, aargs, msig]
+        # XXX: support self type in msig
         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)
+        next unless aargs.consistent_with_method_signature?(msig, subst)
+        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)
+          subst.merge!({ tyvar_elem => recv.elems.squash_or_any })
+        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
@@ -179,54 +216,57 @@ module TypeProf
         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
+          dummy_env = Env.new(StaticEnv.new(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)
-            nfargs = nfargs.map.with_index do |nfarg, i|
+            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)
-                nfarg = nfarg.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
-                nfarg = nfarg.substitute(subst, Config.options[:type_depth_limit])
+                ty = ty.substitute(subst, Config.options[:type_depth_limit])
               end
-              nfarg = nfarg.remove_type_vars
+              ty = ty.remove_type_vars
               alloc_site2 = alloc_site.add_id(i)
-              dummy_env, nfarg = scratch.localize_type(nfarg, dummy_env, dummy_ep, alloc_site2)
-              nfarg
+              dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site2)
+              ty
             end
-            naargs = ActualArguments.new(nfargs, 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)
-                  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])
+            0.upto(nfargs.opt_tys.size) do |n|
+              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 = {}
+                if blk_ret_ty.consistent?(msig.blk_ty.block_body.ret_ty, subst2)
+                  if 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, recv_orig.base_type) do |elems|
+                        elems.update(nil, subst2[tyvar_elem])
+                      end
+                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                     end
-                    scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  else
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
                   end
-                  ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
                 else
-                  ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  # raise "???"
+                  # XXX: need warning
+                  ret_ty = Type.any
                 end
-              else
-                # raise "???"
-                # XXX: need warning
-                ret_ty = Type.any
+                ret_ty = ret_ty.remove_type_vars
+                # XXX: check the return type from the block
+                # sig.blk_ty.block_body.ret_ty.eql?(_ret_ty) ???
+                scratch.add_return_value!(dummy_ctx, ret_ty)
               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)
+              # scratch.add_return_value!(dummy_ctx, ret_ty) ?
+              # This makes `def foo; 1.times { return "str" }; end` return Integer|String
             end
-            # scratch.add_return_type!(dummy_ctx, ret_ty) ?
-            # This makes `def foo; 1.times { return "str" }; end` return Integer|String
           else
             # XXX: a block is passed to a method that does not accept block.
             # Should we call the passed block with any arguments?
@@ -247,8 +287,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
@@ -259,7 +299,6 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
-      # XXX: ctn?
       scratch.merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env } # for Kernel#lambda
       @impl[recv, mid, aargs, caller_ep, caller_env, scratch, &ctn]
     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 = {}
@@ -129,6 +129,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 +148,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
@@ -215,12 +226,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
@@ -505,58 +519,51 @@ 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, type)
+        @block_body, @type = block_body, type
       end
 
-      attr_reader :iseq, :ep, :type
-
-      def inspect
-        "#<ISeqProc>"
-      end
+      attr_reader :block_body, :type
 
-      def screen_name(scratch)
-        "Proc[#{ scratch.proc_screen_name(self) }]" # TODO: use RBS syntax
+      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::Proc
+          @block_body.consistent?(other.block_body)
+        else
+          self == other
+        end
       end
 
       def get_method(mid, scratch)
         @type.get_method(mid, scratch)
       end
 
-      def substitute(_subst, _depth)
-        self # XXX
-      end
-    end
-
-    class TypedProc < Type
-      def initialize(fargs, ret_ty, type)
-        # XXX: need to receive blk_ty?
-        # XXX: may refactor "arguments = arg_tys * blk_ty" out
-        @fargs = fargs
-        @ret_ty = ret_ty
-        @type = type
+      def substitute(subst, depth)
+        Proc.new(@block_body.substitute(subst, depth), @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)
@@ -566,7 +573,7 @@ module TypeProf
         when Symbol
           @sym == other.sym
         else
-          @type.consistent?(other, subst)
+          @base_type.consistent?(other, subst)
         end
       end
 
@@ -574,12 +581,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)
@@ -639,10 +646,9 @@ module TypeProf
       end
     end
 
-    def self.gen_hash
+    def self.gen_hash(base_ty = Type::Instance.new(Type::Builtin[:hash]))
       hg = HashGenerator.new
       yield hg
-      base_ty = Type::Instance.new(Type::Builtin[:hash])
       Type::Hash.new(Type::Hash::Elements.new(hg.map_tys), base_ty)
     end
 
@@ -739,66 +745,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
+      if blks != []
+        str << " " if str != ""
+        str << "?" if optional
+        str << scratch.show_block_signature(blks)
       end
-      # intentionally skip blk_ty
-      fargs
+
+      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)
@@ -813,8 +827,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
@@ -862,231 +874,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]
+        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
-      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
-        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