typeprof 0.3.0 → 0.4.0

data/lib/typeprof/analyzer.rb

@@ -182,22 +182,8 @@ module TypeProf
       Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
     end
 
-    def deploy_cell_type(alloc_site, elems, base_ty)
-      local_ty = Type::LocalCell.new(alloc_site, base_ty)
-      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
-      nenv = Env.new(@static_env, @locals, @stack, type_params)
-      return nenv, local_ty
-    end
-
-    def deploy_array_type(alloc_site, elems, base_ty)
-      local_ty = Type::LocalArray.new(alloc_site, base_ty)
-      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
-      nenv = Env.new(@static_env, @locals, @stack, type_params)
-      return nenv, local_ty
-    end
-
-    def deploy_hash_type(alloc_site, elems, base_ty)
-      local_ty = Type::LocalHash.new(alloc_site, base_ty)
+    def deploy_type(klass, alloc_site, elems, base_ty)
+      local_ty = klass.new(alloc_site, base_ty)
       type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
       nenv = Env.new(@static_env, @locals, @stack, type_params)
       return nenv, local_ty
@@ -244,8 +230,11 @@ module TypeProf
 
       @alloc_site_to_global_id = {}
 
-      @callsites, @return_envs, @sig_fargs, @sig_ret, @yields = {}, {}, {}, {}, {}
+      @callsites, @return_envs = {}, {}
       @block_to_ctx = {}
+      @method_signatures = {}
+      @block_signatures = {}
+      @return_values = {}
       @gvar_table = VarTable.new
 
       @errors = []
@@ -288,6 +277,7 @@ module TypeProf
 
     class ClassDef # or ModuleDef
       def initialize(kind, name, superclass, absolute_path)
+        raise unless name.is_a?(Array)
         @kind = kind
         @superclass = superclass
         @modules = { true => {}, false => {} }
@@ -297,9 +287,10 @@ module TypeProf
         @ivars = VarTable.new
         @cvars = VarTable.new
         @absolute_path = absolute_path
+        @namespace = nil
       end
 
-      attr_reader :kind, :modules, :methods, :superclass, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
       def include_module(mod, absolute_path)
@@ -321,14 +312,15 @@ module TypeProf
       end
 
       def get_constant(name)
-        @consts[name] || Type.any # XXX: warn?
+        ty, = @consts[name]
+        ty || Type.any # XXX: warn?
       end
 
-      def add_constant(name, ty)
+      def add_constant(name, ty, absolute_path)
         if @consts[name]
           # XXX: warn!
         end
-        @consts[name] = ty
+        @consts[name] = [ty, absolute_path]
       end
 
       def get_method(mid, singleton)
@@ -391,12 +383,12 @@ module TypeProf
       end
     end
 
+    def cbase_path(cbase)
+      cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
+    end
+
     def new_class(cbase, name, type_params, superclass, absolute_path)
-      if cbase && cbase.idx != 1
-        show_name = "#{ @class_defs[cbase.idx].name }::#{ name }"
-      else
-        show_name = name.to_s
-      end
+      show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
         if superclass == :__root__
@@ -408,14 +400,14 @@ module TypeProf
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
-        add_constant(cbase, name, klass)
+        add_constant(cbase, name, klass, absolute_path)
         return klass
       else
         # module
         @class_defs[idx] = ClassDef.new(:module, show_name, nil, absolute_path)
         mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
-        add_constant(cbase, name, mod)
+        add_constant(cbase, name, mod, absolute_path)
         return mod
       end
     end
@@ -425,8 +417,8 @@ module TypeProf
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
-      @class_defs[idx] = ClassDef.new(:class, "(Struct)", superclass.idx, ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, "(Struct)")
+      @class_defs[idx] = ClassDef.new(:class, ["(Anonymous Struct)"], superclass.idx, ep.ctx.iseq.absolute_path)
+      klass = Type::Class.new(:class, idx, [], superclass, "(Anonymous Struct)")
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -434,11 +426,25 @@ module TypeProf
       klass
     end
 
+    attr_accessor :namespace
+
     def get_class_name(klass)
       if klass == Type.any
         "???"
       else
-        @class_defs[klass.idx].name
+        path = @class_defs[klass.idx].name
+        if @namespace
+          i = 0
+          i += 1 while @namespace[i] && @namespace[i] == path[i]
+          if path[i]
+            path[i..].join("::")
+          else
+            path.last.to_s
+          end
+        else
+          #"::" + path.join("::")
+          path.join("::")
+        end
       end
     end
 
@@ -488,11 +494,11 @@ module TypeProf
       Type.any
     end
 
-    def add_constant(klass, name, value)
+    def add_constant(klass, name, value, user_defined)
       if klass == Type.any
         self
       else
-        @class_defs[klass.idx].add_constant(name, value)
+        @class_defs[klass.idx].add_constant(name, value, user_defined)
       end
     end
 
@@ -527,14 +533,6 @@ module TypeProf
       add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref))
     end
 
-    def add_typed_method(recv_ty, mid, fargs, ret_ty)
-      add_method(recv_ty.klass, mid, false, TypedMethodDef.new([[fargs, ret_ty]]))
-    end
-
-    def add_singleton_typed_method(recv_ty, mid, fargs, ret_ty)
-      add_method(recv_ty.klass, mid, true, TypedMethodDef.new([[fargs, ret_ty]]))
-    end
-
     def set_custom_method(klass, mid, impl)
       set_method(klass, mid, false, CustomMethodDef.new(impl))
     end
@@ -572,7 +570,7 @@ module TypeProf
       @callsites[callee_ctx][caller_ep] = ctn
       merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env }
 
-      ret_ty = @sig_ret[callee_ctx] ||= Type.bot
+      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]]
@@ -580,11 +578,11 @@ module TypeProf
       end
     end
 
-    def add_signature!(callee_ctx, fargs)
-      if @sig_fargs[callee_ctx]
-        @sig_fargs[callee_ctx] = @sig_fargs[callee_ctx].merge(fargs)
+    def add_method_signature!(callee_ctx, msig)
+      if @method_signatures[callee_ctx]
+        @method_signatures[callee_ctx] = @method_signatures[callee_ctx].merge(msig)
       else
-        @sig_fargs[callee_ctx] = fargs
+        @method_signatures[callee_ctx] = msig
       end
     end
 
@@ -592,9 +590,9 @@ module TypeProf
       @return_envs[caller_ep] = yield @return_envs[caller_ep]
     end
 
-    def add_return_type!(callee_ctx, ret_ty)
-      @sig_ret[callee_ctx] ||= Type.bot
-      @sig_ret[callee_ctx] = @sig_ret[callee_ctx].union(ret_ty)
+    def add_return_value!(callee_ctx, ret_ty)
+      @return_values[callee_ctx] ||= Type.bot
+      @return_values[callee_ctx] = @return_values[callee_ctx].union(ret_ty)
 
       @callsites[callee_ctx] ||= {}
       @callsites[callee_ctx].each do |caller_ep, ctn|
@@ -602,19 +600,18 @@ module TypeProf
       end
     end
 
-    def add_yield!(caller_ctx, aargs, blk_ctx)
-      aargs_acc, = @yields[caller_ctx]
-      if aargs_acc
-        @yields[caller_ctx][0] = aargs_acc.merge(aargs)
-      else
-        @yields[caller_ctx] = [aargs, Utils::MutableSet.new]
-      end
-      @yields[caller_ctx][1] << blk_ctx
+    def add_block_to_ctx!(block_body, ctx)
+      raise if !block_body.is_a?(Block)
+      @block_to_ctx[block_body] ||= Utils::MutableSet.new
+      @block_to_ctx[block_body] << ctx
     end
 
-    def add_block_to_ctx!(blk, ctx)
-      @block_to_ctx[blk] ||= Utils::MutableSet.new
-      @block_to_ctx[blk] << ctx
+    def add_block_signature!(block_body, bsig)
+      if @block_signatures[block_body]
+        @block_signatures[block_body] = @block_signatures[block_body].merge(bsig)
+      else
+        @block_signatures[block_body] = bsig
+      end
     end
 
     class VarTable
@@ -736,7 +733,7 @@ module TypeProf
       env.get_container_elem_types(id)
     end
 
-    def update_container_elem_types(env, ep, id)
+    def update_container_elem_types(env, ep, id, base_type)
       if ep.outer
         tmp_ep = ep
         tmp_ep = tmp_ep.outer while tmp_ep.outer
@@ -746,7 +743,7 @@ module TypeProf
           menv = menv.update_container_elem_types(id, elems)
           gid = @alloc_site_to_global_id[id]
           if gid
-            ty = globalize_type(elems.to_local_type(id), env, ep)
+            ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
             add_ivar_write!(*gid, ty, ep)
           end
           menv
@@ -758,7 +755,7 @@ module TypeProf
         env = env.update_container_elem_types(id, elems)
         gid = @alloc_site_to_global_id[id]
         if gid
-          ty = globalize_type(elems.to_local_type(id), env, ep)
+          ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
           add_ivar_write!(*gid, ty, ep)
         end
         env
@@ -770,7 +767,7 @@ module TypeProf
 
       if elems
         return elems[idx] || Type.nil if idx
-        return elems.squash
+        return elems.squash_or_any
       else
         Type.any
       end
@@ -836,9 +833,10 @@ module TypeProf
           add_iseq_method_call!(meth, ep.ctx)
 
         when :block
-          epenvs = dummy_continuation
+          blk, epenvs = dummy_continuation
           epenvs.each do |ep, env|
             merge_env(ep, env)
+            add_block_to_ctx!(blk.block_body, ep.ctx)
           end
         end
       end
@@ -856,12 +854,7 @@ module TypeProf
 
       Reporters.show_gvars(self, @gvar_table, output)
 
-      #RubySignatureExporter2.new(
-      #  self, @include_relations, @ivar_table.write, @cvar_table.write, @class_defs
-      #).show
-
-      #return
-      RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs, @sig_fargs, @sig_ret, @yields).show(stat_eps, output)
+      RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs).show(stat_eps, output)
     end
 
     def globalize_type(ty, env, ep)
@@ -915,12 +908,12 @@ module TypeProf
       @pending_execution[iseq] ||= [:method, [meth, ep, env]]
     end
 
-    def pend_block_dummy_execution(iseq, nep, nenv)
-      @pending_execution[iseq] ||= [:block, {}]
-      if @pending_execution[iseq][1][nep]
-        @pending_execution[iseq][1][nep] = @pending_execution[iseq][1][nep].merge(nenv)
+    def pend_block_dummy_execution(blk, iseq, nep, nenv)
+      @pending_execution[iseq] ||= [:block, [blk, {}]]
+      if @pending_execution[iseq][1][1][nep]
+        @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
       else
-        @pending_execution[iseq][1][nep] = nenv
+        @pending_execution[iseq][1][1][nep] = nenv
       end
     end
 
@@ -929,7 +922,7 @@ module TypeProf
         alloc_site = AllocationSite.new(ep)
         nenv, ty = localize_type(ty, env, ep, alloc_site)
         case ty
-        when Type::LocalArray, Type::LocalHash
+        when Type::LocalCell, Type::LocalArray, Type::LocalHash
           @alloc_site_to_global_id[ty.id] = [recv, var] # need overwrite check??
         end
         yield ty, nenv
@@ -954,7 +947,7 @@ module TypeProf
       end
 
       case insn
-      when :_method_body
+      when :_iseq_body_start
         # XXX: reconstruct and record the method signature
         iseq = ep.ctx.iseq
         lead_num = iseq.fargs_format[:lead_num] || 0
@@ -1006,9 +999,15 @@ module TypeProf
           end
         end
         kw_rest_ty = globalize_type(env.locals[kw_rest], env, ep) if kw_rest
-        blk_ty = block_start ? globalize_type(env.locals[block_start], env, ep) : Type.nil
-        fargs = FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
-        add_signature!(ep.ctx, fargs)
+        if block_start
+          blk_ty = globalize_type(env.locals[block_start], env, ep)
+        elsif iseq.type == :method
+          blk_ty = env.static_env.blk_ty
+        else
+          blk_ty = Type.nil
+        end
+        msig = MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
+        add_method_signature!(ep.ctx, msig)
       when :putspecialobject
         kind, = operands
         ty = case kind
@@ -1188,7 +1187,7 @@ module TypeProf
         end
         return
       when :send
-        env, recvs, mid, aargs = setup_actual_arguments(operands, ep, env)
+        env, recvs, mid, aargs = setup_actual_arguments(:method, operands, ep, env)
         recvs = Type.any if recvs == Type.bot
         recvs.each_child do |recv|
           do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
@@ -1200,7 +1199,7 @@ module TypeProf
         return
       when :send_branch
         getlocal_operands, send_operands, branch_operands = operands
-        env, recvs, mid, aargs = setup_actual_arguments(send_operands, ep, env)
+        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
         recvs.each_child do |recv|
           do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
@@ -1227,11 +1226,7 @@ module TypeProf
         end
         return
       when :invokeblock
-        # XXX: need block parameter, unknown block, etc.  Use setup_actual_arguments
-        opt, = operands
-        _flags = opt[:flag]
-        orig_argc = opt[:orig_argc]
-        env, aargs = env.pop(orig_argc)
+        env, recvs, mid, aargs = setup_actual_arguments(:block, operands, ep, env)
         blk = env.static_env.blk_ty
         case
         when blk == Type.nil
@@ -1240,10 +1235,7 @@ module TypeProf
           #warn(ep, "block is any")
           env = env.push(Type.any)
         else # Proc
-          blk_nil = Type.nil
-          #
-          aargs = ActualArguments.new(aargs, nil, {}, blk_nil)
-          do_invoke_block(true, env.static_env.blk_ty, aargs, ep, env) do |ret_ty, ep, env|
+          do_invoke_block(blk, aargs, ep, env) do |ret_ty, ep, env|
             nenv, ret_ty, = localize_type(ret_ty, env, ep)
             nenv = nenv.push(ret_ty)
             merge_env(ep.next, nenv)
@@ -1251,7 +1243,7 @@ module TypeProf
           return
         end
       when :invokesuper
-        env, recv, _, aargs = setup_actual_arguments(operands, ep, env)
+        env, recv, _, aargs = setup_actual_arguments(:method, operands, ep, env)
 
         env, recv = localize_type(env.static_env.recv_ty, env, ep)
         mid  = ep.ctx.mid
@@ -1284,7 +1276,7 @@ module TypeProf
         end
         env, (ty,) = env.pop(1)
         ty = globalize_type(ty, env, ep)
-        add_return_type!(ep.ctx, ty)
+        add_return_value!(ep.ctx, ty)
         return
       when :throw
         throwtype, = operands
@@ -1298,7 +1290,7 @@ module TypeProf
           ty = globalize_type(ty, env, ep)
           tmp_ep = ep
           tmp_ep = tmp_ep.outer while tmp_ep.outer
-          add_return_type!(tmp_ep.ctx, ty)
+          add_return_value!(tmp_ep.ctx, ty)
           return
         when :break
           tmp_ep = ep
@@ -1444,8 +1436,37 @@ module TypeProf
           flow_env = env.local_update(-var_idx+2, ret_ty)
           case ret_ty
           when Type.any
-            merge_env(ep_then, env)
-            merge_env(ep_else, env)
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
+          when Type::Instance.new(Type::Builtin[:false]), Type.nil
+            merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+          else
+            merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+          end
+        end
+        return
+      when :getlocal_dup_branch
+        getlocal_operands, _dup_operands, branch_operands = operands
+        var_idx, _scope_idx, _escaped = getlocal_operands
+        ret_ty = env.get_local(-var_idx+2)
+        unless ret_ty
+          p env.locals
+          raise
+        end
+
+        branchtype, target, = branch_operands
+        # branchtype: :if or :unless or :nil
+        ep_then = ep.next
+        ep_else = ep.jump(target)
+
+        var_idx, _scope_idx, _escaped = getlocal_operands
+
+        ret_ty.each_child do |ret_ty|
+          flow_env = env.local_update(-var_idx+2, ret_ty).push(ret_ty)
+          case ret_ty
+          when Type.any
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
           when Type::Instance.new(Type::Builtin[:false]), Type.nil
             merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
           else
@@ -1469,6 +1490,10 @@ module TypeProf
 
         ret_ty.each_child do |ret_ty|
           flow_env = env.local_update(-var_idx+2, ret_ty)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::Symbol)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalCell)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalArray)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalHash)
           if ret_ty.is_a?(Type::Instance)
             if ret_ty.klass == pattern_ty # XXX: inheritance
               merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
@@ -1476,8 +1501,8 @@ module TypeProf
               merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
             end
           else
-            merge_env(ep_then, env)
-            merge_env(ep_else, env)
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
           end
         end
         return
@@ -1518,10 +1543,10 @@ module TypeProf
         end
         ty.each_child do |ty|
           if ty.is_a?(Type::Class) && ty.superclass == Type::Builtin[:struct]
-            @class_defs[ty.idx].name = name.to_s
+            @class_defs[ty.idx].name = cbase_path(cbase) + [name]
           end
         end
-        add_constant(cbase, name, globalize_type(ty, env, ep))
+        add_constant(cbase, name, globalize_type(ty, env, ep), ep.ctx.iseq.absolute_path)
 
       when :getspecial
         key, type = operands
@@ -1550,6 +1575,28 @@ module TypeProf
       when :dup
         env, (ty,) = env.pop(1)
         env = env.push(ty).push(ty)
+      when :dup_branch
+        _dup_operands, branch_operands = operands
+        env, (ty,) = env.pop(1)
+
+        branchtype, target, = branch_operands
+        # branchtype: :if or :unless or :nil
+        ep_then = ep.next
+        ep_else = ep.jump(target)
+
+        ty.each_child do |ty|
+          flow_env = env.push(ty)
+          case ty
+          when Type.any
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
+          when Type::Instance.new(Type::Builtin[:false]), Type.nil
+            merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+          else
+            merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+          end
+        end
+        return
       when :duphash
         raw_hash, = operands
         ty = Type.guess_literal_type(raw_hash)
@@ -1639,11 +1686,11 @@ module TypeProf
           if ary2.is_a?(Type::LocalArray)
             elems2 = get_container_elem_types(env, ep, ary2.id)
             elems = Type::Array::Elements.new([], elems1.squash.union(elems2.squash))
-            env = update_container_elem_types(env, ep, ary1.id) { elems }
+            env = update_container_elem_types(env, ep, ary1.id, ary1.base_type) { elems }
             env = env.push(ary1)
           else
             elems = Type::Array::Elements.new([], Type.any)
-            env = update_container_elem_types(env, ep, ary1.id) { elems }
+            env = update_container_elem_types(env, ep, ary1.id, ary1.base_type) { elems }
             env = env.push(ary1)
           end
         else
@@ -1714,13 +1761,13 @@ module TypeProf
       merge_env(ep.next, env)
     end
 
-    private def setup_actual_arguments(operands, ep, env)
+    private def setup_actual_arguments(kind, operands, ep, env)
       opt, blk_iseq = operands
       flags = opt[:flag]
       mid = opt[:mid]
       kw_arg = opt[:kw_arg]
       argc = opt[:orig_argc]
-      argc += 1 # receiver
+      argc += 1 if kind == :method # for the receiver
       argc += kw_arg.size if kw_arg
 
       flag_args_splat    = flags[ 0] != 0
@@ -1735,29 +1782,36 @@ module TypeProf
       _flag_super        = flags[ 9] != 0
       _flag_zsuper       = flags[10] != 0
 
+      argc += 1 if flag_args_blockarg
+
+      env, aargs = env.pop(argc)
+
+      recv = aargs.shift if kind == :method
+
       if flag_args_blockarg
-        env, (recv, *aargs, blk_ty) = env.pop(argc + 1)
-        raise "both block arg and actual block given" if blk_iseq
+        blk_ty = aargs.pop
+      elsif blk_iseq
+        blk_ty = Type::Proc.new(ISeqBlock.new(blk_iseq, ep), Type::Instance.new(Type::Builtin[:proc]))
       else
-        env, (recv, *aargs) = env.pop(argc)
-        if blk_iseq
-          # check
-          blk_ty = Type::ISeqProc.new(blk_iseq, ep, Type::Instance.new(Type::Builtin[:proc]))
-        else
-          blk_ty = Type.nil
-        end
+        blk_ty = Type.nil
       end
 
+      new_blk_ty = Type.bot
       blk_ty.each_child do |blk_ty|
         case blk_ty
         when Type.nil
         when Type.any
-        when Type::ISeqProc
+        when Type::Proc
+        when Type::Symbol
+          blk_ty = Type::Proc.new(SymbolBlock.new(blk_ty.sym), Type::Instance.new(Type::Builtin[:proc]))
         else
+          # XXX: attempt to call to_proc
           error(ep, "wrong argument type #{ blk_ty.screen_name(self) } (expected Proc)")
           blk_ty = Type.any
         end
+        new_blk_ty = new_blk_ty.union(blk_ty)
       end
+      blk_ty = new_blk_ty
 
       if flag_args_splat
         # assert !flag_args_kwarg
@@ -1841,7 +1895,7 @@ module TypeProf
         nlocals = [Type.any] * blk_iseq.locals.size
         nsenv = StaticEnv.new(env.static_env.recv_ty, Type.any, env.static_env.mod_func)
         nenv = Env.new(nsenv, nlocals, [], nil)
-        pend_block_dummy_execution(blk_iseq, nep, nenv)
+        pend_block_dummy_execution(blk_ty, blk_iseq, nep, nenv)
         merge_return_env(ep) {|tenv| tenv ? tenv.merge(env) : env }
       end
 
@@ -1866,153 +1920,83 @@ module TypeProf
       end
     end
 
-    def do_invoke_block(given_block, blk, aargs, ep, env, replace_recv_ty: nil, &ctn)
+    def do_invoke_block(blk, aargs, ep, env, replace_recv_ty: nil, &ctn)
       blk.each_child do |blk|
-        unless blk.is_a?(Type::ISeqProc)
-          warn(ep, "non-iseq-proc is passed as a block")
-          next
-        end
-        blk_iseq = blk.iseq
-        blk_ep = blk.ep
-        blk_env = @return_envs[blk_ep]
-        blk_env = blk_env.replace_recv_ty(replace_recv_ty) if replace_recv_ty
-        arg_blk = aargs.blk_ty
-        aargs_ = aargs.lead_tys.map {|aarg| globalize_type(aarg, env, ep) }
-        # XXX: aargs.opt_tys and aargs.kw_tys
-        argc = blk_iseq.fargs_format[:lead_num] || 0
-        # actual argc == 1, not array, formal argc == 1: yield 42         => do |x|   : x=42
-        # actual argc == 1,     array, formal argc == 1: yield [42,43,44] => do |x|   : x=[42,43,44]
-        # actual argc >= 2,            formal argc == 1: yield 42,43,44   => do |x|   : x=42
-        # actual argc == 1, not array, formal argc >= 2: yield 42         => do |x,y| : x,y=42,nil
-        # actual argc == 1,     array, formal argc >= 2: yield [42,43,44] => do |x,y| : x,y=42,43
-        # actual argc >= 2,            formal argc >= 2: yield 42,43,44   => do |x,y| : x,y=42,43
-        if aargs_.size >= 2 || argc == 0
-          aargs_.pop while argc < aargs_.size
-          aargs_ << Type.nil while argc > aargs_.size
+        if blk.is_a?(Type::Proc)
+          blk.block_body.do_call(aargs, ep, env, self, replace_recv_ty: replace_recv_ty, &ctn)
         else
-          aarg_ty, = aargs_
-          if argc == 1
-            aargs_ = [aarg_ty || Type.nil]
-          else # actual argc == 1 && formal argc >= 2
-            ary_elems = nil
-            any_ty = nil
-            case aarg_ty
-            when Type::Union
-              ary_elems = nil
-              other_elems = nil
-              aarg_ty.elems&.each do |(container_kind, base_type), elems|
-                if container_kind == Type::Array
-                  ary_elems = ary_elems ? ary_elems.union(elems) : elems
-                else
-                  other_elems = other_elems ? other_elems.union(elems) : elems
-                end
-              end
-              aarg_ty = Type::Union.new(aarg_ty.types, other_elems)
-              any_ty = Type.any if aarg_ty.types.include?(Type.any)
-            when Type::Array
-              ary_elems = aarg_ty.elems
-              aarg_ty = nil
-            when Type::Any
-              any_ty = Type.any
-            end
-            aargs_ = [Type.bot] * argc
-            aargs_[0] = aargs_[0].union(aarg_ty) if aarg_ty
-            argc.times do |i|
-              ty = aargs_[i]
-              ty = ty.union(ary_elems[i]) if ary_elems
-              ty = ty.union(Type.any) if any_ty
-              ty = ty.union(Type.nil) if i >= 1 && aarg_ty
-              aargs_[i] = ty
-            end
-          end
+          warn(ep, "non-proc is passed as a block")
+          ctn[Type.any, ep, env]
         end
-        locals = [Type.nil] * blk_iseq.locals.size
-        locals[blk_iseq.fargs_format[:block_start]] = arg_blk if blk_iseq.fargs_format[:block_start]
-        env_blk = blk_env.static_env.blk_ty
-        nfargs = FormalArguments.new(aargs_, [], nil, [], nil, nil, env_blk)
-        nctx = Context.new(blk_iseq, blk_ep.ctx.cref, nil)
-        nep = ExecutionPoint.new(nctx, 0, blk_ep)
-        nenv = Env.new(blk_env.static_env, locals, [], nil)
-        alloc_site = AllocationSite.new(nep)
-        aargs_.each_with_index do |ty, i|
-          alloc_site2 = alloc_site.add_id(i)
-          nenv, ty = localize_type(ty, nenv, nep, alloc_site2) # Use Scratch#localize_type?
-          nenv = nenv.local_update(i, ty)
-        end
-
-        merge_env(nep, nenv)
-
-        # caution: given_block flag is not complete
-        #
-        # def foo
-        #   bar do |&blk|
-        #     yield
-        #     blk.call
-        #   end
-        # end
-        #
-        # yield and blk.call call different blocks.
-        # So, a context can have two blocks.
-        # given_block is calculated by comparing "context's block (yield target)" and "blk", but it is not a correct result
-
-        add_yield!(ep.ctx, globalize_type(aargs, env, ep), nep.ctx) if given_block
-        add_block_to_ctx!(blk, nep.ctx)
-        add_callsite!(nep.ctx, ep, env, &ctn)
-        add_signature!(nep.ctx, nfargs)
       end
     end
 
-    def proc_screen_name(blk)
-      blk_ctxs = []
-      blk.each_child_global do |blk|
-        if @block_to_ctx[blk]
-          @block_to_ctx[blk].each do |ctx|
-            blk_ctxs << [ctx, @sig_fargs[ctx]]
+    def show_block_signature(blks)
+      bsig = nil
+      ret_ty = Type.bot
+
+      blks.each do |blk|
+        blk.each_child_global do |blk|
+          bsig0 = @block_signatures[blk.block_body]
+          if bsig0
+            if bsig
+              bsig = bsig.merge(bsig0)
+            else
+              bsig = bsig0
+            end
+          end
+
+          @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
-        else
-          # uncalled proc? dummy execution doesn't work?
-          #p blk
         end
       end
-      show_block_signature(blk_ctxs)
+
+      bsig ||= BlockSignature.new([], [], nil, Type.nil)
+
+      bsig = bsig.screen_name(self)#, block: true)
+      ret_ty = ret_ty.screen_name(self)
+      ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
+
+      bsig = bsig + " " if bsig != ""
+      "{ #{ bsig }-> #{ ret_ty } }"
     end
 
-    def show_block_signature(blk_ctxs)
-      all_farg_tys = all_ret_tys = nil
-      blk_ctxs.each do |blk_ctx, farg_tys|
-        if all_farg_tys
-          all_farg_tys = all_farg_tys.merge(farg_tys)
-        else
-          all_farg_tys = farg_tys
-        end
+    def show_proc_signature(blks)
+      farg_tys, ret_ty = nil, Type.bot
 
-        if all_ret_tys
-          all_ret_tys = all_ret_tys.union(@sig_ret[blk_ctx])
-        else
-          all_ret_tys = @sig_ret[blk_ctx]
+      blks.each do |blk|
+        blk.each_child_global do |blk|
+          next if blk.block_body.is_a?(TypedBlock) # XXX: Support TypedBlock
+          next unless @block_to_ctx[blk.block_body] # this occurs when screen_name is called before type-profiling finished (e.g., error message)
+          @block_to_ctx[blk.block_body].each do |blk_ctx|
+            if farg_tys
+              farg_tys = farg_tys.merge(@method_signatures[blk_ctx])
+            else
+              farg_tys = @method_signatures[blk_ctx]
+            end
+
+            ret_ty = ret_ty.union(@return_values[blk_ctx]) if @return_values[blk_ctx]
+          end
         end
       end
-      return "" if !all_farg_tys
-      # XXX: should support @yields[blk_ctx] (block's block)
-      show_signature(all_farg_tys, nil, all_ret_tys)
+
+      farg_tys = farg_tys ? farg_tys.screen_name(self) : "(unknown)"
+      ret_ty = ret_ty.screen_name(self)
+      ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
+
+      farg_tys = farg_tys + " " if farg_tys != ""
+      "^#{ farg_tys }-> #{ ret_ty }"
     end
 
-    def show_signature(farg_tys, yield_data, ret_ty)
+    def show_method_signature(ctx)
+      farg_tys = @method_signatures[ctx]
+      ret_ty = @return_values[ctx] || Type.bot
+
       farg_tys = farg_tys.screen_name(self)
       ret_ty = ret_ty.screen_name(self)
-      s = farg_tys.empty? ? "" : "(#{ farg_tys.join(", ") }) "
-      if yield_data
-        aargs, blk_ctxs = yield_data
-        all_blk_ret_ty = Type.bot
-        blk_ctxs.each do |blk_ctx|
-          all_blk_ret_ty = all_blk_ret_ty.union(@sig_ret[blk_ctx])
-        end
-        all_blk_ret_ty = all_blk_ret_ty.screen_name(self)
-        all_blk_ret_ty = all_blk_ret_ty.include?("|") ? "(#{ all_blk_ret_ty })" : all_blk_ret_ty
-        s << "{ #{ aargs.screen_name(self) } -> #{ all_blk_ret_ty } } " if aargs
-      end
-      s << "-> "
-      s << (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty)
+      ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
+      "#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }"
     end
   end
 end