typeprof 0.1.2 → 0.4.0

data/doc/doc.ja.md

@@ -1,5 +1,9 @@
 # TypeProf: 抽象解釈に基づくRubyコードの型解析ツール
 
+## とりあえずデモ
+
+[demo.md](demo.md) を参照。
+
 ## TypeProfの使い方
 
 app.rb を解析する。
@@ -24,7 +28,13 @@ $ 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の結果は出力される）。
+* `--include-dir DIR`: `DIR`以下のファイルの解析結果を出力に含める。後に指定されているほうが優先される（`--exclude-dir foo --include-dir foo/bar`の場合、
+foo/bar/baz.rbの結果は出力されるが、foo/baz.rbの結果は出力されない）。
 * `-fshow-errors`: 実行中に見つけたバグの可能性を出力します（多くの場合、大量のfalse positiveが出ます）。
 * `-fpedantic-output`: デフォルトでは`A | untyped`と推定されたところを単に`A`と出力しますが、より生の出力、つまり`A | untyped`と出力します。
 * `-fshow-container-raw-elements`: （後で書く）

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,12 @@ 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.)
+* `--include-dir DIR`: Show the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--exclude-dir foo --include-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is shown, but foo/baz.rb is omitted.)
 * `-fshow-errors`: Prints out possible bugs found during execution (often a lot of false positives).
 * `-fpedantic-output`: When TypeProf inferred a type `A | untyped`, it simply outputs `A` by default. But this option forces it to output `A | untyped`.
 * `-fshow-container-raw-elements`: (undocumented yet)
@@ -50,7 +59,7 @@ p foo(42)  #=> String
 The analysis results of TypeProf are as follows.
 
 ```
-$ ruby exe/type-profiler test.rb
+$ ruby exe/typeprof test.rb
 # Revealed types
 #  test.rb:2 #=> Integer
 #  test.rb:6 #=> String
@@ -84,7 +93,7 @@ p Foo.new.a #=> Integer | String
 ```
 
 ```
-$ ruby exe/type-profiler test.rb
+$ ruby exe/typeprof test.rb
 # Revealed types
 #  test.rb:11 #=> Integer | String
 
@@ -230,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)
@@ -299,7 +308,7 @@ class Object
   def foo: (Integer) -> Integer | (String) -> String
 end
 ```
- 
+
 ```
 # test.rb
 def foo(n)
@@ -386,9 +395,9 @@ You can update the types; this allows the following code to initialize the array
 ```
 def foo
   a = []
-  
+
   100.times {|n| a << n.to_s}
-  
+
   a
 end
 

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

@@ -128,7 +128,13 @@ 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
+                if elems.is_a?(Array) # should be refactored as Cell::Elements
+                  type_params[id] = elems.zip(elems2).map {|elem1, elem2| elem1.union(elem2) }
+                else
+                  type_params[id] = elems.union(elems2)
+                end
+              end
             else
               type_params[id] = elems
             end
@@ -176,15 +182,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,12 +230,13 @@ 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
 
-      @include_relations = {}
-
       @errors = []
       @reveal_types = {}
       @backward_edges = {}
@@ -247,6 +247,8 @@ module TypeProf
       @loaded_features = {}
 
       @rbs_reader = RBSReader.new
+
+      @terminated = false
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -261,7 +263,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
@@ -274,48 +276,56 @@ module TypeProf
     attr_reader :class_defs
 
     class ClassDef # or ModuleDef
-      def initialize(kind, name, superclass)
+      def initialize(kind, name, superclass, absolute_path)
+        raise unless name.is_a?(Array)
         @kind = kind
         @superclass = superclass
-        @modules = { true => [], false => [] }
+        @modules = { true => {}, false => {} }
         @name = name
         @consts = {}
         @methods = {}
         @ivars = VarTable.new
         @cvars = VarTable.new
+        @absolute_path = absolute_path
+        @namespace = nil
       end
 
-      attr_reader :kind, :modules, :methods, :superclass, :ivars, :cvars
+      attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, visible)
+      def include_module(mod, absolute_path)
         # XXX: need to check if mod is already included by the ancestors?
-        unless @modules[false].include?([visible, mod])
-          @modules[false] << [visible, mod]
+        absolute_paths = @modules[false][mod]
+        unless absolute_paths
+          @modules[false][mod] = absolute_paths = Utils::MutableSet.new
         end
+        absolute_paths << absolute_path
       end
 
-      def extend_module(mod, visible)
+      def extend_module(mod, absolute_path)
         # XXX: need to check if mod is already included by the ancestors?
-        unless @modules[true].include?([visible, mod])
-          @modules[true] << [visible, mod]
+        absolute_paths = @modules[true][mod]
+        unless absolute_paths
+          @modules[true][mod] = absolute_paths = Utils::MutableSet.new
         end
+        absolute_paths << absolute_path
       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)
         @methods[[singleton, mid]] || begin
-          @modules[singleton].reverse_each do |_visible, mod|
+          @modules[singleton].each_key do |mod|
             meth = mod.get_method(mid, false)
             return meth if meth
           end
@@ -336,22 +346,22 @@ module TypeProf
         @methods[[singleton, mid]] << mdef
         # Need to restart...?
       end
+
+      def set_method(mid, singleton, mdef)
+        @methods[[singleton, mid]] = Utils::MutableSet.new
+        @methods[[singleton, mid]] << mdef
+      end
     end
 
-    def include_module(including_mod, included_mod, visible = true)
+    def include_module(including_mod, included_mod, absolute_path)
       return if included_mod == Type.any
 
-      if visible
-        @include_relations[including_mod] ||= Utils::MutableSet.new
-        @include_relations[including_mod] << included_mod
-      end
-
       including_mod = @class_defs[including_mod.idx]
       included_mod.each_child do |included_mod|
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, visible)
+            including_mod.include_module(included_mod, absolute_path)
           else
             warn "including something that is not a module"
           end
@@ -359,13 +369,13 @@ module TypeProf
       end
     end
 
-    def extend_module(extending_mod, extended_mod, visible = true)
+    def extend_module(extending_mod, extended_mod, absolute_path)
       extending_mod = @class_defs[extending_mod.idx]
       extended_mod.each_child do |extended_mod|
         if extended_mod.is_a?(Type::Class)
           extended_mod = @class_defs[extended_mod.idx]
           if extended_mod && extended_mod.kind == :module
-            extending_mod.extend_module(extended_mod, visible)
+            extending_mod.extend_module(extended_mod, absolute_path)
           else
             warn "extending something that is not a module"
           end
@@ -373,12 +383,12 @@ module TypeProf
       end
     end
 
-    def new_class(cbase, name, type_params, superclass)
-      if cbase && cbase.idx != 0
-        show_name = "#{ @class_defs[cbase.idx].name }::#{ name }"
-      else
-        show_name = name.to_s
-      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)
+      show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
         if superclass == :__root__
@@ -386,18 +396,18 @@ module TypeProf
         else
           superclass_idx = superclass.idx
         end
-        @class_defs[idx] = ClassDef.new(:class, show_name, superclass_idx)
+        @class_defs[idx] = ClassDef.new(:class, show_name, superclass_idx, absolute_path)
         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)
+        @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
@@ -407,8 +417,8 @@ module TypeProf
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
-      @class_defs[idx] = ClassDef.new(:class, "(Struct)", superclass.idx)
-      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
@@ -416,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
 
@@ -470,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
 
@@ -487,12 +511,17 @@ module TypeProf
       mdef
     end
 
-    def add_attr_method(klass, mid, ivar, kind)
+    def set_method(klass, mid, singleton, mdef)
+      @class_defs[klass.idx].set_method(mid, singleton, mdef)
+      mdef
+    end
+
+    def add_attr_method(klass, absolute_path, mid, ivar, kind)
       if kind == :reader || kind == :accessor
-        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader))
+        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, absolute_path))
       end
       if kind == :writer || kind == :accessor
-        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer))
+        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, absolute_path))
       end
     end
 
@@ -504,20 +533,12 @@ 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 add_custom_method(klass, mid, impl)
-      add_method(klass, mid, false, CustomMethodDef.new(impl))
+    def set_custom_method(klass, mid, impl)
+      set_method(klass, mid, false, CustomMethodDef.new(impl))
     end
 
-    def add_singleton_custom_method(klass, mid, impl)
-      add_method(klass, mid, true, CustomMethodDef.new(impl))
+    def set_singleton_custom_method(klass, mid, impl)
+      set_method(klass, mid, true, CustomMethodDef.new(impl))
     end
 
     def alias_method(klass, singleton, new, old)
@@ -542,33 +563,36 @@ 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
-      end
-      ret_ty = @sig_ret[callee_ctx] ||= Type.bot
-      unless ret_ty.eql?(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]]
         end
       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
+
     def merge_return_env(caller_ep)
       @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|
@@ -576,43 +600,54 @@ 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
+      Entry = Struct.new(:rbs_declared, :read_continuations, :type, :absolute_paths)
+
       def initialize
-        @read, @write = {}, {}
+        @tbl = {}
       end
 
-      attr_reader :write
-
       def add_read!(site, ep, &ctn)
-        @read[site] ||= {}
-        @read[site][ep] = ctn
-        @write[site] ||= Type.bot
-        ctn[@write[site], ep]
+        entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new)
+        entry.read_continuations[ep] = ctn
+        entry.absolute_paths << ep.ctx.iseq.absolute_path
+        ctn[entry.type, ep]
       end
 
-      def add_write!(site, ty, &ctn)
-        @write[site] ||= Type.bot
-        @write[site] = @write[site].union(ty)
-        @read[site] ||= {}
-        @read[site].each do |ep, ctn|
+      def add_write!(site, ty, ep, scratch)
+        entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new)
+        if ep
+          if entry.rbs_declared
+            if !entry.type.consistent?(ty, {})
+              scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
+              return
+            end
+          end
+          entry.absolute_paths << ep.ctx.iseq.absolute_path
+        end
+        entry.type = entry.type.union(ty)
+        entry.read_continuations.each do |ep, ctn|
           ctn[ty, ep]
         end
       end
+
+      def dump
+        @tbl
+      end
     end
 
     def get_ivar(recv)
@@ -637,11 +672,11 @@ module TypeProf
       end
     end
 
-    def add_ivar_write!(recv, var, ty, &ctn)
+    def add_ivar_write!(recv, var, ty, ep)
       recv.each_child do |recv|
         class_def, singleton = get_ivar(recv)
         next unless class_def
-        class_def.ivars.add_write!([singleton, var], ty, &ctn)
+        class_def.ivars.add_write!([singleton, var], ty, ep, self)
       end
     end
 
@@ -653,11 +688,11 @@ module TypeProf
       end
     end
 
-    def add_cvar_write!(klass, var, ty, &ctn)
+    def add_cvar_write!(klass, var, ty, ep)
       klass.each_child do |klass|
         class_def = @class_defs[klass.idx]
         next unless class_def
-        class_def.cvars.add_write!(var, ty, &ctn)
+        class_def.cvars.add_write!(var, ty, ep, self)
       end
     end
 
@@ -665,8 +700,8 @@ module TypeProf
       @gvar_table.add_read!(var, ep, &ctn)
     end
 
-    def add_gvar_write!(var, ty, &ctn)
-      @gvar_table.add_write!(var, ty, &ctn)
+    def add_gvar_write!(var, ty, ep)
+      @gvar_table.add_write!(var, ty, ep, self)
     end
 
     def error(ep, msg)
@@ -698,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
@@ -708,8 +743,8 @@ 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)
-            add_ivar_write!(*gid, ty)
+            ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
+            add_ivar_write!(*gid, ty, ep)
           end
           menv
         end
@@ -720,8 +755,8 @@ 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)
-          add_ivar_write!(*gid, ty)
+          ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
+          add_ivar_write!(*gid, ty, ep)
         end
         env
       end
@@ -732,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
@@ -749,20 +784,35 @@ module TypeProf
     end
 
     def type_profile
-      counter = 0
+      start_time = tick = Time.now
+      iter_counter = 0
       stat_eps = Utils::MutableSet.new
+
       while true
         until @worklist.empty?
-          counter += 1
-          if counter % 1000 == 0 && Config.verbose >= 1
-            puts "iter %d, remain: %d" % [counter, @worklist.size]
-            #exit if counter == 20000
+          ep = @worklist.deletemin
+
+          iter_counter += 1
+          if Config.verbose >= 1
+            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
+
+          if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
+            @terminated = true
+            break
           end
-          @ep = @worklist.deletemin
-          stat_eps << @ep
-          step(@ep) # TODO: deletemin
+
+          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
@@ -782,61 +832,29 @@ 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
+      $stderr.print "\r\e[K" if Config.verbose >= 1
 
       stat_eps
     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.write, output)
-
-      #RubySignatureExporter2.new(
-      #  self, @include_relations, @ivar_table.write, @cvar_table.write, @class_defs
-      #).show
+      Reporters.show_gvars(self, @gvar_table, output)
 
-      #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)
@@ -867,17 +885,35 @@ module TypeProf
       ctx = Context.new(iseq, cref, mid)
       ep = ExecutionPoint.new(ctx, 0, nil)
       locals = [Type.any] * iseq.locals.size
+
+      keyword = iseq.fargs_format[:keyword]
+      if keyword
+        kw_start = iseq.fargs_format[:kwbits]
+        kw_start -= iseq.fargs_format[:keyword].size if kw_start
+        keyword.each_with_index do |kw, i|
+          case
+          when kw.is_a?(Symbol) # required keyword
+          when kw.size == 2 # optional keyword (default value is a literal)
+            _key, default_ty = *kw
+            default_ty = Type.guess_literal_type(default_ty)
+            default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
+            locals[kw_start + i] = default_ty.union(Type.any)
+          else # optional keyword (default value is an expression)
+          end
+        end
+      end
+
       env = Env.new(StaticEnv.new(recv, Type.any, 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
 
@@ -886,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
@@ -895,7 +931,7 @@ module TypeProf
 
     def set_instance_variable(recv, var, ty, ep, env)
       ty = globalize_type(ty, env, ep)
-      add_ivar_write!(recv, var, ty)
+      add_ivar_write!(recv, var, ty, ep)
     end
 
     def step(ep)
@@ -911,6 +947,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.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
@@ -985,6 +1082,7 @@ module TypeProf
         recv = env.static_env.recv_ty
         if cref.klass.is_a?(Type::Class)
           typed_mdef = check_typed_method(cref.klass, mid, ep.ctx.cref.singleton)
+          recv = Type::Instance.new(recv) if recv.is_a?(Type::Class)
           if typed_mdef
             mdef = ISeqMethodDef.new(iseq, cref)
             typed_mdef.each do |typed_mdef|
@@ -1000,7 +1098,6 @@ module TypeProf
               end
             end
 
-            recv = Type::Instance.new(recv) if recv.is_a?(Type::Class)
             pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref)
           end
         else
@@ -1043,7 +1140,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")
@@ -1058,7 +1155,7 @@ module TypeProf
               if cbase == Type.any
                 klass = Type.any
               else
-                klass = new_class(cbase, id, [], superclass)
+                klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
               end
             end
           end
@@ -1083,14 +1180,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|
@@ -1102,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|
@@ -1129,23 +1226,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)
@@ -1153,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
@@ -1186,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
@@ -1200,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
@@ -1238,7 +1328,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)
@@ -1254,7 +1344,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
@@ -1284,7 +1374,7 @@ module TypeProf
         cbase = ep.ctx.cref.klass
         ty = globalize_type(ty, env, ep)
         # TODO: if superclass has the variable, it should be updated
-        add_cvar_write!(cbase, var, ty)
+        add_cvar_write!(cbase, var, ty, ep)
 
       when :getclassvariable
         var, = operands
@@ -1300,7 +1390,7 @@ module TypeProf
         var, = operands
         env, (ty,) = env.pop(1)
         ty = globalize_type(ty, env, ep)
-        add_gvar_write!(var, ty)
+        add_gvar_write!(var, ty, ep)
 
       when :getglobal
         var, = operands
@@ -1311,7 +1401,6 @@ module TypeProf
           env = env.push(ty)
         else
           add_gvar_read!(var, ep) do |ty, ep|
-            ty = Type.nil if ty == Type.bot # HACK
             nenv, ty = localize_type(ty, env, ep)
             merge_env(ep.next, nenv.push(ty))
           end
@@ -1347,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
@@ -1372,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)
@@ -1379,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
@@ -1401,11 +1523,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)
@@ -1421,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
@@ -1453,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)
@@ -1542,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
@@ -1585,7 +1729,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)
@@ -1617,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
@@ -1638,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
@@ -1672,33 +1823,38 @@ 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|
@@ -1706,31 +1862,30 @@ module TypeProf
               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
@@ -1740,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
 
@@ -1754,158 +1909,94 @@ module TypeProf
           meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
         end
       else
-        if recv != Type.any # XXX: should be configurable
+        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) }
-        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
-        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) # XXX: aargs_ -> fargs
-        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)
+          warn(ep, "non-proc is passed as a block")
+          ctn[Type.any, ep, env]
         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