typeprof 0.2.0 → 0.5.0

data/doc/doc.ja.md

@@ -1,5 +1,9 @@
 # TypeProf: 抽象解釈に基づくRubyコードの型解析ツール
 
+## とりあえずデモ
+
+[demo.md](demo.md) を参照。
+
 ## TypeProfの使い方
 
 app.rb を解析する。
@@ -24,7 +28,8 @@ $ typeprof sig/app.rbs app.rb -o sig/app.gen.rbs
 
 * `-o OUTFILE`: 標準出力ではなく、指定ファイル名に出力する
 * `-q`: 解析の進捗を表示しない
-* `-v`: 解析の詳細ログを表示する（現状ではデバッグ用出力に近い）
+* `-v`: `-fshow-errors`の別名
+* `-d`: 解析の詳細ログを表示する（現状ではデバッグ用出力に近い）
 * `-I DIR`: `require`のファイル探索ディレクトリを追加する
 * `-r GEMNAME`: `GEMNAME`に対応するRBSをロードする
 * `--exclude-dir DIR`: `DIR`以下のファイルの解析結果を出力から省略する。後に指定されているほうが優先される（`--include-dir foo --exclude-dir foo/bar`の場合う、foo/bar/baz.rbの結果は出力されず、foo/baz.rbの結果は出力される）。

data/doc/doc.md

@@ -1,5 +1,9 @@
 # TypeProf: A type analysis tool for Ruby code based on abstract interpretation
 
+## Show me demo first
+
+See [demo.md](demo.md).
+
 ## How to use TypeProf
 
 Analyze app.rb:
@@ -24,7 +28,8 @@ Here is a list of currently avaiable options:
 
 * `-o OUTFILE`: Write the analyze result to OUTFILE instead of standard output
 * `-q`: Hide the progress indicator
-* `-v`: Show the analysis log (Currently, the log is just for debugging and may become very huge)
+* `-v`: Alias to `-fshow-errors`
+* `-d`: Show the analysis log (Currently, the log is just for debugging and may become very huge)
 * `-I DIR`: Add `DIR` to the file search path of `require`
 * `-r GEMNAME`: Load the RBS files of `GEMNAME`
 * `--exclude-dir DIR`: Omit the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--include-dir foo --exclude-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is omitted, but foo/baz.rb is shown.)
@@ -234,7 +239,7 @@ If a method returns different abstract values, it can lead to retrospective exec
 Even after TypeProf traced all programs as possible, there may be methods or blocks that aren't executed.
 For example, a method is not executed if it is called from nowhere; this is typical for library method that has no test.
 (Basically, when you use TypeProf, it is recommended to invoke all methods with supposed argument types.)
-TypeProf forcibly calls these unreachable methods and blocks with `untyped` as argumetns.
+TypeProf forcibly calls these unreachable methods and blocks with `untyped` as arguments.
 
 ```
 def foo(n)

data/exe/typeprof

@@ -2,4 +2,5 @@
 
 require_relative "../lib/typeprof"
 
-TypeProf::CLI.new(ARGV).run
+config = TypeProf::CLI.parse(ARGV)
+TypeProf.analyze(config)

data/lib/typeprof.rb

@@ -1,11 +1,20 @@
+unless defined?(RubyVM::InstructionSequence)
+  puts "Currently, TypeProf can work on a Ruby implementation that supports RubyVM::InstructionSequence, such as CRuby."
+  exit 1
+end
+
 module TypeProf end
 
+require_relative "typeprof/version"
+require_relative "typeprof/config"
 require_relative "typeprof/insns-def"
 require_relative "typeprof/utils"
 require_relative "typeprof/type"
 require_relative "typeprof/container-type"
 require_relative "typeprof/method"
+require_relative "typeprof/block"
 require_relative "typeprof/iseq"
+require_relative "typeprof/arguments"
 require_relative "typeprof/analyzer"
 require_relative "typeprof/import"
 require_relative "typeprof/export"

data/lib/typeprof/analyzer.rb

@@ -87,6 +87,11 @@ module TypeProf
       @recv_ty = recv_ty
       @blk_ty = blk_ty
       @mod_func = mod_func
+
+      return if recv_ty == :top #OK
+      recv_ty.each_child_global do |ty|
+        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && ty != Type.any
+      end
     end
 
     attr_reader :recv_ty, :blk_ty, :mod_func
@@ -128,7 +133,9 @@ module TypeProf
           other.type_params.internal_hash.each do |id, elems|
             elems2 = type_params[id]
             if elems2
-              type_params[id] = elems.union(elems2) if elems != elems2
+              if elems != elems2
+                type_params[id] = elems.union(elems2)
+              end
             else
               type_params[id] = elems
             end
@@ -145,6 +152,8 @@ module TypeProf
       tys.each do |ty|
         raise "nil cannot be pushed to the stack" if ty.nil?
         ty.each_child do |ty|
+          raise if ty.is_a?(Type::Var)
+          #raise if ty.is_a?(Type::Instance) && ty.klass.type_params.size > 1
           raise "Array cannot be pushed to the stack" if ty.is_a?(Type::Array)
           raise "Hash cannot be pushed to the stack" if ty.is_a?(Type::Hash)
         end
@@ -176,15 +185,8 @@ module TypeProf
       Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
     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
@@ -231,8 +233,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 = []
@@ -245,6 +250,8 @@ module TypeProf
       @loaded_features = {}
 
       @rbs_reader = RBSReader.new
+
+      @terminated = false
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -259,7 +266,7 @@ module TypeProf
       env2 = @ep2env[ep]
       if env2
         nenv = env2.merge(env)
-        if !nenv.eql?(env2) && !@worklist.member?(ep)
+        if nenv != env2 && !@worklist.member?(ep)
           @worklist.insert(ep.key, ep)
         end
         @ep2env[ep] = nenv
@@ -273,6 +280,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 => {} }
@@ -282,9 +290,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)
@@ -306,14 +315,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)
@@ -376,12 +386,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__
@@ -393,14 +403,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
@@ -410,8 +420,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
@@ -419,11 +429,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
 
@@ -473,11 +497,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
 
@@ -512,14 +536,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
@@ -550,23 +566,24 @@ module TypeProf
       @iseq_method_to_ctxs[iseq_mdef] << ctx
     end
 
-    def add_callsite!(callee_ctx, fargs, caller_ep, caller_env, &ctn)
+    def add_callsite!(callee_ctx, caller_ep, caller_env, &ctn)
       @executed_iseqs << callee_ctx.iseq if callee_ctx.is_a?(Context)
 
       @callsites[callee_ctx] ||= {}
       @callsites[callee_ctx][caller_ep] = ctn
       merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env }
 
-      if @sig_fargs[callee_ctx]
-        @sig_fargs[callee_ctx] = @sig_fargs[callee_ctx].merge(fargs)
-      else
-        @sig_fargs[callee_ctx] = fargs
+      ret_ty = @return_values[callee_ctx] ||= Type.bot
+      if ret_ty != Type.bot
+        ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
       end
-      ret_ty = @sig_ret[callee_ctx] ||= Type.bot
-      unless ret_ty.eql?(Type.bot)
-        @callsites[callee_ctx].each do |caller_ep, ctn|
-          ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
-        end
+    end
+
+    def add_method_signature!(callee_ctx, msig)
+      if @method_signatures[callee_ctx]
+        @method_signatures[callee_ctx] = @method_signatures[callee_ctx].merge(msig)
+      else
+        @method_signatures[callee_ctx] = msig
       end
     end
 
@@ -574,9 +591,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|
@@ -584,19 +601,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
@@ -617,7 +633,7 @@ module TypeProf
         entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new)
         if ep
           if entry.rbs_declared
-            if !entry.type.consistent?(ty, {})
+            unless Type.match?(ty, entry.type)
               scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
               return
             end
@@ -636,6 +652,7 @@ module TypeProf
     end
 
     def get_ivar(recv)
+      recv = recv.base_type while recv.respond_to?(:base_type)
       case recv
       when Type::Class
         [@class_defs[recv.idx], true]
@@ -718,7 +735,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
@@ -728,7 +745,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
@@ -740,7 +757,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
@@ -752,7 +769,7 @@ module TypeProf
 
       if elems
         return elems[idx] || Type.nil if idx
-        return elems.squash
+        return elems.squash_or_any
       else
         Type.any
       end
@@ -769,27 +786,35 @@ module TypeProf
     end
 
     def type_profile
-      time = Time.now
-      step_counter = 0
+      start_time = tick = Time.now
+      iter_counter = 0
       stat_eps = Utils::MutableSet.new
+
       while true
         until @worklist.empty?
-          @ep = @worklist.deletemin
+          ep = @worklist.deletemin
 
-          step_counter += 1
+          iter_counter += 1
           if Config.verbose >= 1
-            time2 = Time.now
-            if time2 - time >= 1
-              time = time2
-              $stderr << "\rType Profiling... (%d steps @ %s)\e[K" % [step_counter, @ep.source_location]
+            tick2 = Time.now
+            if tick2 - tick >= 1
+              tick = tick2
+              $stderr << "\rType Profiling... (%d steps @ %s)\e[K" % [iter_counter, ep.source_location]
               $stderr.flush
             end
           end
 
-          stat_eps << @ep
-          step(@ep)
+          if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
+            @terminated = true
+            break
+          end
+
+          stat_eps << ep
+          step(ep)
         end
 
+        break if @terminated
+
         # XXX: it would be good to provide no-dummy-execution mode.
         # It should work as a bit smarter "rbs prototype rb";
         # show all method definitions as "untyped" arguments and return values
@@ -809,41 +834,11 @@ module TypeProf
           merge_env(ep, env)
           add_iseq_method_call!(meth, ep.ctx)
 
-          fargs_format = iseq.fargs_format
-          lead_tys = [Type.any] * (fargs_format[:lead_num] || 0)
-          opt_tys = fargs_format[:opt] ? [] : nil
-          post_tys = [Type.any] * (fargs_format[:post_num] || 0)
-          if fargs_format[:kwbits]
-            kw_tys = []
-            fargs_format[:keyword].each do |kw|
-              case
-              when kw.is_a?(Symbol) # required keyword
-                key = kw
-                req = true
-                ty = Type.any
-              when kw.size == 2 # optional keyword (default value is a literal)
-                key, ty = *kw
-                ty = Type.guess_literal_type(ty)
-                ty = ty.type if ty.is_a?(Type::Literal)
-              else # optional keyword
-                key, = kw
-                req = false
-                ty = Type.any
-              end
-              kw_tys << [req, key, ty]
-            end
-          else
-            kw_tys = nil
-          end
-          fargs = FormalArguments.new(lead_tys, opt_tys, nil, post_tys, kw_tys, nil, nil)
-          add_callsite!(ep.ctx, fargs, nil, nil) do |_ret_ty, _ep, _env|
-            # ignore
-          end
-
         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
@@ -853,18 +848,15 @@ module TypeProf
     end
 
     def report(stat_eps, output)
+      Reporters.show_message(@terminated, output)
+
       Reporters.show_error(@errors, @backward_edges, output)
 
       Reporters.show_reveal_types(self, @reveal_types, output)
 
       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)
@@ -894,18 +886,51 @@ module TypeProf
     def pend_method_execution(iseq, meth, recv, mid, cref)
       ctx = Context.new(iseq, cref, mid)
       ep = ExecutionPoint.new(ctx, 0, nil)
-      locals = [Type.any] * iseq.locals.size
-      env = Env.new(StaticEnv.new(recv, Type.any, false), locals, [], Utils::HashWrapper.new({}))
+      locals = [Type.nil] * iseq.locals.size
+
+      fargs_format = iseq.fargs_format
+      lead_num = fargs_format[:lead_num] || 0
+      post_num = fargs_format[:post_num] || 0
+      post_index = fargs_format[:post_start]
+      rest_index = fargs_format[:rest_start]
+      keyword = fargs_format[:keyword]
+      kw_index = fargs_format[:kwbits] - keyword.size if keyword
+      kwrest_index = fargs_format[:kwrest]
+      block_index = fargs_format[:block_start]
+      opt = fargs_format[:opt] || [0]
+
+      (lead_num + opt.size - 1).times {|i| locals[i] = Type.any }
+      post_num.times {|i| locals[i + post_index] = Type.any } if post_index
+      locals[rest_index] = Type.any if rest_index
+      if keyword
+        keyword.each_with_index do |kw, i|
+          case
+          when kw.is_a?(Symbol) # required keyword
+            locals[kw_index + i] = Type.any
+          when kw.size == 2 # optional keyword (default value is a literal)
+            _key, default_ty = *kw
+            default_ty = Type.guess_literal_type(default_ty)
+            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
+            locals[kw_index + i] = default_ty.union(Type.any)
+          else # optional keyword (default value is an expression)
+            locals[kw_index + i] = Type.any
+          end
+        end
+      end
+      locals[kwrest_index] = Type.any if kwrest_index
+      locals[block_index] = Type.nil if block_index
+
+      env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
 
       @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
 
@@ -914,7 +939,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
@@ -939,6 +964,67 @@ module TypeProf
       end
 
       case insn
+      when :_iseq_body_start
+        # XXX: reconstruct and record the method signature
+        iseq = ep.ctx.iseq
+        lead_num = iseq.fargs_format[:lead_num] || 0
+        opt = iseq.fargs_format[:opt] || [0]
+        rest_start = iseq.fargs_format[:rest_start]
+        post_start = iseq.fargs_format[:post_start]
+        post_num = iseq.fargs_format[:post_num] || 0
+        kw_start = iseq.fargs_format[:kwbits]
+        keyword = iseq.fargs_format[:keyword]
+        kw_start -= keyword.size if kw_start
+        kw_rest = iseq.fargs_format[:kwrest]
+        block_start = iseq.fargs_format[:block_start]
+
+        lead_tys = env.locals[0, lead_num].map {|ty| globalize_type(ty, env, ep) }
+        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : nil
+        if rest_start # XXX:squash
+          ty = globalize_type(env.locals[lead_num + opt.size - 1], env, ep)
+          rest_ty = Type.bot
+          ty.each_child_global do |ty|
+            if ty.is_a?(Type::Array)
+              rest_ty = rest_ty.union(ty.elems.squash)
+            else
+              # XXX: to_ary?
+              rest_ty = rest_ty.union(ty)
+            end
+          end
+        end
+        post_tys = (post_start ? env.locals[post_start, post_num] : []).map {|ty| globalize_type(ty, env, ep) }
+        if keyword
+          kw_tys = []
+          keyword.each_with_index do |kw, i|
+            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.base_type if default_ty.is_a?(Type::Literal)
+              req = false
+            else # optional keyword (default value is an expression)
+              key, = kw
+              req = false
+            end
+            ty = env.locals[kw_start + i]
+            ty = ty.union(default_ty) if default_ty
+            ty = globalize_type(ty, env, ep)
+            kw_tys << [req, key, ty]
+          end
+        end
+        kw_rest_ty = globalize_type(env.locals[kw_rest], env, ep) if kw_rest
+        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
@@ -960,7 +1046,17 @@ module TypeProf
         ty = Type::Literal.new(str, Type::Instance.new(Type::Builtin[:str]))
         env = env.push(ty)
       when :putself
-        env, ty = localize_type(env.static_env.recv_ty, env, ep)
+        ty = env.static_env.recv_ty
+        if ty.is_a?(Type::Instance)
+          klass = ty.klass
+          if klass.type_params.size >= 1
+            ty = Type::ContainerType.create_empty_instance(klass)
+            env, ty = localize_type(ty, env, ep, AllocationSite.new(ep))
+          else
+            ty = Type::Instance.new(klass)
+          end
+          env, ty = localize_type(ty, env, ep)
+        end
         env = env.push(ty)
       when :newarray, :newarraykwsplat
         len, = operands
@@ -1071,7 +1167,7 @@ module TypeProf
                 elsif superclass == Type.any
                   warn(ep, "superclass is any; Object is used instead")
                   superclass = Type::Builtin[:obj]
-                elsif superclass.eql?(Type.nil)
+                elsif superclass == Type.nil
                   superclass = Type::Builtin[:obj]
                 elsif superclass.is_a?(Type::Instance)
                   warn(ep, "superclass is an instance; Object is used instead")
@@ -1111,14 +1207,14 @@ module TypeProf
         locals = [Type.nil] * iseq.locals.size
         nenv = Env.new(StaticEnv.new(recv, blk, false), locals, [], Utils::HashWrapper.new({}))
         merge_env(nep, nenv)
-        add_callsite!(nep.ctx, nil, ep, env) do |ret_ty, ep, env|
+        add_callsite!(nep.ctx, 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)
         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|
@@ -1130,7 +1226,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|
@@ -1157,23 +1253,16 @@ 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.eql?(Type.nil)
+        when blk == Type.nil
           env = env.push(Type.any)
-        when blk.eql?(Type.any)
+        when blk == Type.any
           #warn(ep, "block is any")
           env = env.push(Type.any)
         else # Proc
-          blk_nil = Type.nil
-          #
-          aargs = ActualArguments.new(aargs, nil, 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)
@@ -1181,7 +1270,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
@@ -1214,7 +1303,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
@@ -1228,7 +1317,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
@@ -1266,7 +1355,7 @@ module TypeProf
         raise if iseq.locals != []
         nenv = Env.new(env.static_env, [], [], nil)
         merge_env(nep, nenv)
-        add_callsite!(nep.ctx, nil, ep, env) do |ret_ty, ep, env|
+        add_callsite!(nep.ctx, 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)
@@ -1282,7 +1371,7 @@ module TypeProf
 
         # TODO: it works for only simple cases: `x = nil; x || 1`
         # It would be good to merge "dup; branchif" to make it context-sensitive-like
-        falsy = ty.eql?(Type.nil)
+        falsy = ty == Type.nil
 
         merge_env(ep_then, env)
         merge_env(ep_else, env) unless branchtype == :if && falsy
@@ -1374,8 +1463,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
@@ -1399,6 +1517,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)
@@ -1406,8 +1528,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
@@ -1428,11 +1550,11 @@ module TypeProf
       when :getconstant
         name, = operands
         env, (cbase, _allow_nil,) = env.pop(2)
-        if cbase.eql?(Type.nil)
+        if cbase == Type.nil
           ty = search_constant(ep.ctx.cref, name)
           env, ty = localize_type(ty, env, ep)
           env = env.push(ty)
-        elsif cbase.eql?(Type.any)
+        elsif cbase == Type.any
           env = env.push(Type.any) # XXX: warning needed?
         else
           ty = get_constant(cbase, name)
@@ -1448,10 +1570,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
@@ -1480,6 +1602,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)
@@ -1569,11 +1713,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
@@ -1583,15 +1727,27 @@ module TypeProf
         end
 
       when :checktype
-        type, = operands
-        raise NotImplementedError if type != 5 # T_STRING
-        # XXX: is_a?
-        env, (val,) = env.pop(1)
-        res = globalize_type(val, env, ep) == Type::Instance.new(Type::Builtin[:str])
-        if res
-          ty = Type::Instance.new(Type::Builtin[:true])
+        kind, = operands
+        case kind
+        when 5 then klass = :str  # T_STRING
+        when 7 then klass = :ary  # T_ARRAY
+        when 8 then klass = :hash # T_HASH
         else
-          ty = Type::Instance.new(Type::Builtin[:false])
+          raise NotImplementedError
+        end
+        env, (val,) = env.pop(1)
+        ty = Type.bot
+        val.each_child do |val|
+        #globalize_type(val, env, ep).each_child_global do |val|
+          val = val.base_type while val.respond_to?(:base_type)
+          case val
+          when Type::Instance.new(Type::Builtin[klass])
+            ty = ty.union(Type::Instance.new(Type::Builtin[:true]))
+          when Type.any
+            ty = Type.bool
+          else
+            ty = ty.union(Type::Instance.new(Type::Builtin[:false]))
+          end
         end
         env = env.push(ty)
       else
@@ -1612,7 +1768,7 @@ module TypeProf
           locals = [Type.nil] * iseq.locals.size
           nenv = Env.new(env.static_env, locals, [], Utils::HashWrapper.new({}))
           merge_env(nep, nenv)
-          add_callsite!(nep.ctx, nil, cont_ep, cont_env) do |ret_ty, ep, env|
+          add_callsite!(nep.ctx, cont_ep, cont_env) do |ret_ty, ep, env|
             nenv, ret_ty = localize_type(ret_ty, env, ep)
             nenv = nenv.push(ret_ty)
             merge_env(ep.jump(cont), nenv)
@@ -1644,13 +1800,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
@@ -1665,29 +1821,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
@@ -1699,65 +1862,69 @@ module TypeProf
             _, (ty,) = ty.elems.take_last(1)
             case ty
             when Type::Hash
-              kw_ty = ty
+              kw_tys = ty.elems.to_keywords
             when Type::Union
               hash_elems = nil
               ty.elems&.each do |(container_kind, base_type), elems|
                 if container_kind == Type::Hash
+                  elems.to_keywords
                   hash_elems = hash_elems ? hash_elems.union(elems) : elems
                 end
               end
-              hash_elems ||= Type::Hash::Elements.new({Type.any => Type.any})
-              kw_ty = Type::Hash.new(hash_elems, Type::Instance.new(Type::Builtin[:hash]))
+              if hash_elems
+                kw_tys = hash_elems.to_keywords
+              else
+                kw_tys = { nil => Type.any }
+              end
             else
               warn(ep, "non hash is passed to **kwarg?") unless ty == Type.any
-              kw_ty = nil
+              kw_tys = { nil => Type.any }
             end
           else
             raise NotImplementedError
           end
-          # XXX: should we remove kw_ty from rest_ty?
+        else
+          kw_tys = {}
         end
-        aargs = ActualArguments.new(aargs, rest_ty, kw_ty, blk_ty)
+        aargs = ActualArguments.new(aargs, rest_ty, kw_tys, blk_ty)
       elsif flag_args_kw_splat
         last = aargs.last
         ty = globalize_type(last, env, ep)
         case ty
         when Type::Hash
           aargs = aargs[0..-2]
-          kw_ty = ty
+          kw_tys = ty.elems.to_keywords
         when Type::Union
           hash_elems = nil
-          ty.elems.each do |(container_kind, base_type), elems|
+          ty.elems&.each do |(container_kind, base_type), elems|
             if container_kind == Type::Hash
               hash_elems = hash_elems ? hash_elems.union(elems) : elems
             end
           end
-          hash_elems ||= Type::Hash::Elements.new({Type.any => Type.any})
-          kw_ty = Type::Hash.new(hash_elems, Type::Instance.new(Type::Builtin[:hash]))
+          if hash_elems
+            kw_tys = hash_elems.to_keywords
+          else
+            kw_tys = { nil => Type.any }
+          end
         when Type::Any
           aargs = aargs[0..-2]
-          kw_ty = ty
+          kw_tys = { nil => Type.any }
         else
           warn(ep, "non hash is passed to **kwarg?")
-          kw_ty = nil
+          kw_tys = { nil => Type.any }
         end
-        aargs = ActualArguments.new(aargs, nil, kw_ty, blk_ty)
+        aargs = ActualArguments.new(aargs, nil, kw_tys, blk_ty)
       elsif flag_args_kwarg
         kw_vals = aargs.pop(kw_arg.size)
 
-        kw_ty = Type.gen_hash do |h|
-          kw_arg.zip(kw_vals) do |key, v_ty|
-            k_ty = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
-            h[k_ty] = v_ty
-          end
+        kw_tys = {}
+        kw_arg.zip(kw_vals) do |key, v_ty|
+          kw_tys[key] = v_ty
         end
 
-        # kw_ty is Type::Hash, but we don't have to localize it, maybe?
-
-        aargs = ActualArguments.new(aargs, nil, kw_ty, blk_ty)
+        aargs = ActualArguments.new(aargs, nil, kw_tys, blk_ty)
       else
-        aargs = ActualArguments.new(aargs, nil, nil, blk_ty)
+        aargs = ActualArguments.new(aargs, nil, {}, blk_ty)
       end
 
       if blk_iseq
@@ -1767,7 +1934,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
 
@@ -1781,159 +1948,94 @@ module TypeProf
           meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
         end
       else
-        if recv != Type.any
+        case recv
+        when Type::Void
+          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+        when Type::Any
+        else
           error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
         end
         ctn[Type.any, ep, env]
       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_ty
-        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, nfargs, ep, env, &ctn)
       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