typeprof 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c01f41e130c6e3bbc112520904ed710a75dea1b167ea112e96a321cd1bceadf
-  data.tar.gz: 1b61e75c07cc8d24570bd998ea852f850b22264aaa1eed1bda425efe11660fba
+  metadata.gz: 3a0f0b09ed34d40d00fc280008ae562863d6cb3e19bd0a421e1fc5ac5023a5ea
+  data.tar.gz: dd7ee377c5dee6d2ad7bbd274844a5136c59f7fab5f7491cde11fcac628d44c2
 SHA512:
-  metadata.gz: ba66753bc6fe6b21939449ede398ee31c27aa06893884a3e93baebcf60439c9552fa0b1da1b8fd6158f83ef012966f275c83055ba94d2974c10f694e031c40ab
-  data.tar.gz: 6f6d9e688c024eefead28c9fe847686d172919a0c3ae0f5f6441bcb79d947710265e77dc52e4c5d44be699d7ea6bcd978943d0a898621956e6991a19c3874ac0
+  metadata.gz: 66e931b5f52fb1436707623ad1fba698bed0cf6e922971fbd0b5c99e28e4c14f5737e5f92406a457c5b96205ef8ad58f31aa739465f3aa57ca8149695c1bda42
+  data.tar.gz: 679c4b14a7bad664ba17f2aa27aa999a27584d7b9fdbe40bbb82fc4ea836ef867621a34077de5931c6c26fc9e9c9a2908bb4901914fa587f1b84cdd75dcde0ea

data/.gitignore

@@ -7,3 +7,4 @@ testbed/diff-lcs
 pkg/
 *.log
 .*.sw*
+*.dump

data/Gemfile

@@ -7,7 +7,7 @@ group :development do
   gem "rake"
   gem "stackprof"
   gem "test-unit"
-  gem "simplecov", github: "simplecov-ruby/simplecov"
-  gem "simplecov-html", github: "simplecov-ruby/simplecov-html", ref: "6567856c6940e285bbb70cce98edca60c7dfefdd"
+  gem "simplecov"
+  gem "simplecov-html"
   gem "coverage-helpers"
 end

data/Gemfile.lock

@@ -1,23 +1,8 @@
-GIT
-  remote: https://github.com/simplecov-ruby/simplecov-html.git
-  revision: 6567856c6940e285bbb70cce98edca60c7dfefdd
-  ref: 6567856c6940e285bbb70cce98edca60c7dfefdd
-  specs:
-    simplecov-html (0.12.2)
-
-GIT
-  remote: https://github.com/simplecov-ruby/simplecov.git
-  revision: 80700ec9f9b5ae426c22d06f62620f7e7b71ff42
-  specs:
-    simplecov (0.18.5)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-
 PATH
   remote: .
   specs:
-    typeprof (0.1.4)
-      rbs (>= 0.12.0)
+    typeprof (0.3.0)
+      rbs (>= 0.13.1)
 
 GEM
   remote: https://rubygems.org/
@@ -27,7 +12,11 @@ GEM
     power_assert (1.2.0)
     rake (13.0.1)
     rbs (0.14.0)
-    stackprof (0.2.15)
+    simplecov (0.19.1)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
+    stackprof (0.2.16)
     test-unit (3.3.6)
       power_assert
 
@@ -37,8 +26,8 @@ PLATFORMS
 DEPENDENCIES
   coverage-helpers
   rake
-  simplecov!
-  simplecov-html!
+  simplecov
+  simplecov-html
   stackprof
   test-unit
   typeprof!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Yusuke Endoh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/doc/doc.ja.md

@@ -24,7 +24,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

@@ -24,7 +24,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 +235,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,5 +1,6 @@
 module TypeProf end
 
+require_relative "typeprof/config"
 require_relative "typeprof/insns-def"
 require_relative "typeprof/utils"
 require_relative "typeprof/type"

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,6 +182,13 @@ module TypeProf
       Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
     end
 
+    def deploy_cell_type(alloc_site, elems, base_ty)
+      local_ty = Type::LocalCell.new(alloc_site, base_ty)
+      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
+      nenv = Env.new(@static_env, @locals, @stack, type_params)
+      return nenv, local_ty
+    end
+
     def deploy_array_type(alloc_site, elems, base_ty)
       local_ty = Type::LocalArray.new(alloc_site, base_ty)
       type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
@@ -245,6 +258,8 @@ module TypeProf
       @loaded_features = {}
 
       @rbs_reader = RBSReader.new
+
+      @terminated = false
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -259,7 +274,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
@@ -550,26 +565,29 @@ 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)
+      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_signature!(callee_ctx, fargs)
+      if @sig_fargs[callee_ctx]
+        @sig_fargs[callee_ctx] = @sig_fargs[callee_ctx].merge(fargs)
+      else
+        @sig_fargs[callee_ctx] = fargs
+      end
+    end
+
     def merge_return_env(caller_ep)
       @return_envs[caller_ep] = yield @return_envs[caller_ep]
     end
@@ -769,27 +787,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,37 +835,6 @@ 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
           epenvs.each do |ep, env|
@@ -853,6 +848,8 @@ 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)
@@ -895,6 +892,24 @@ 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]]
@@ -939,6 +954,61 @@ module TypeProf
       end
 
       case insn
+      when :_method_body
+        # 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
+        blk_ty = block_start ? globalize_type(env.locals[block_start], env, ep) : Type.nil
+        fargs = FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
+        add_signature!(ep.ctx, fargs)
       when :putspecialobject
         kind, = operands
         ty = case kind
@@ -1071,7 +1141,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,7 +1181,7 @@ 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)
@@ -1164,15 +1234,15 @@ module TypeProf
         env, aargs = env.pop(orig_argc)
         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)
+          aargs = ActualArguments.new(aargs, nil, {}, blk_nil)
           do_invoke_block(true, env.static_env.blk_ty, aargs, ep, env) do |ret_ty, ep, env|
             nenv, ret_ty, = localize_type(ret_ty, env, ep)
             nenv = nenv.push(ret_ty)
@@ -1266,7 +1336,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 +1352,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
@@ -1428,11 +1498,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)
@@ -1612,7 +1682,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)
@@ -1699,33 +1769,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|
@@ -1733,31 +1808,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
@@ -1781,7 +1855,11 @@ 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]
@@ -1800,7 +1878,7 @@ module TypeProf
         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
+        # XXX: aargs.opt_tys and aargs.kw_tys
         argc = blk_iseq.fargs_format[:lead_num] || 0
         # actual argc == 1, not array, formal argc == 1: yield 42         => do |x|   : x=42
         # actual argc == 1,     array, formal argc == 1: yield [42,43,44] => do |x|   : x=[42,43,44]
@@ -1879,7 +1957,8 @@ module TypeProf
 
         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)
+        add_callsite!(nep.ctx, ep, env, &ctn)
+        add_signature!(nep.ctx, nfargs)
       end
     end