typeprof 0.3.0 → 0.4.0

data/lib/typeprof/import.rb

@@ -264,35 +264,38 @@ module TypeProf
     end
 
     def conv_method_def(rbs_method_types)
-      rbs_method_types.map do |type|
-        blk = type.block ? conv_block(type.block) : nil
-        type_params = type.type_params
-
-        lead_tys = type.type.required_positionals.map {|type| conv_type(type.type) }
-        opt_tys = type.type.optional_positionals.map {|type| conv_type(type.type) }
-        rest_ty = type.type.rest_positionals
-        rest_ty = conv_type(rest_ty.type) if rest_ty
-        opt_kw_tys = type.type.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
-        req_kw_tys = type.type.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
-        rest_kw_ty = type.type.rest_keywords
-        raise NotImplementedError if rest_kw_ty # XXX
-
-        ret_ty = conv_type(type.type.return_type)
-
-        {
-          type_params: type_params,
-          lead_tys: lead_tys,
-          opt_tys: opt_tys,
-          rest_ty: rest_ty,
-          req_kw_tys: req_kw_tys,
-          opt_kw_tys: opt_kw_tys,
-          rest_kw_ty: rest_kw_ty,
-          blk: blk,
-          ret_ty: ret_ty,
-        }
+      rbs_method_types.map do |method_type|
+        conv_func(method_type.type_params, method_type.type, method_type.block)
       end
     end
 
+    def conv_func(type_params, func, block)
+      blk = block ? conv_block(block) : nil
+
+      lead_tys = func.required_positionals.map {|type| conv_type(type.type) }
+      opt_tys = func.optional_positionals.map {|type| conv_type(type.type) }
+      rest_ty = func.rest_positionals
+      rest_ty = conv_type(rest_ty.type) if rest_ty
+      opt_kw_tys = func.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      req_kw_tys = func.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      rest_kw_ty = func.rest_keywords
+      raise NotImplementedError if rest_kw_ty # XXX
+
+      ret_ty = conv_type(func.return_type)
+
+      {
+        type_params: type_params,
+        lead_tys: lead_tys,
+        opt_tys: opt_tys,
+        rest_ty: rest_ty,
+        req_kw_tys: req_kw_tys,
+        opt_kw_tys: opt_kw_tys,
+        rest_kw_ty: rest_kw_ty,
+        blk: blk,
+        ret_ty: ret_ty,
+      }
+    end
+
     def attr_reader_def(ty)
       [{
         type_params: [],
@@ -401,8 +404,10 @@ module TypeProf
           [:instance, conv_type_name(ty.name)]
         end
       when RBS::Types::Bases::Instance then [:any] # XXX: not implemented yet
-      when RBS::Types::Record then [:any] # XXX: not implemented yet
-      when RBS::Types::Proc   then [:any] # XXX: not implemented yet
+      when RBS::Types::Record
+        [:hash_record, [:Hash], ty.fields.map {|key, ty| [key, conv_type(ty)] }]
+      when RBS::Types::Proc
+        [:proc, conv_func(nil, ty.type, nil)]
       else
         warn "unknown RBS type: %p" % ty.class
         [:any]
@@ -463,6 +468,7 @@ module TypeProf
           when [:Symbol]     then Type::Builtin[:sym]   = klass
           when [:Array]      then Type::Builtin[:ary]   = klass
           when [:Hash]       then Type::Builtin[:hash]  = klass
+          when [:Proc]       then Type::Builtin[:proc]  = klass
           end
         end
 
@@ -505,7 +511,7 @@ module TypeProf
       @json[:constants].each do |classpath, value|
         base_klass = path_to_klass(classpath[0..-2])
         value = conv_type(value)
-        @scratch.add_constant(base_klass, classpath[-1], value)
+        @scratch.add_constant(base_klass, classpath[-1], value, nil)
       end
 
       @json[:globals].each do |name, value|
@@ -517,34 +523,38 @@ module TypeProf
 
     def conv_method_def(method_name, mdef, rbs_source)
       sig_rets = mdef.flat_map do |sig_ret|
-        #type_params = sig_ret[:type_params] # XXX
-        lead_tys = sig_ret[:lead_tys]
-        opt_tys = sig_ret[:opt_tys]
-        rest_ty = sig_ret[:rest_ty]
-        req_kw_tys = sig_ret[:req_kw_tys]
-        opt_kw_tys = sig_ret[:opt_kw_tys]
-        rest_kw_ty = sig_ret[:rest_kw_ty]
-        blk = sig_ret[:blk]
-        ret_ty = sig_ret[:ret_ty]
+        conv_func(sig_ret)
+      end
 
-        lead_tys = lead_tys.map {|ty| conv_type(ty) }
-        opt_tys = opt_tys.map {|ty| conv_type(ty) }
-        rest_ty = conv_type(rest_ty) if rest_ty
-        kw_tys = []
-        req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
-        opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
-        kw_rest_ty = conv_type(rest_kw_ty) if rest_kw_ty
+      TypedMethodDef.new(sig_rets, rbs_source)
+    end
 
-        blks = conv_block(blk)
+    def conv_func(sig_ret)
+      #type_params = sig_ret[:type_params] # XXX
+      lead_tys = sig_ret[:lead_tys]
+      opt_tys = sig_ret[:opt_tys]
+      rest_ty = sig_ret[:rest_ty]
+      req_kw_tys = sig_ret[:req_kw_tys]
+      opt_kw_tys = sig_ret[:opt_kw_tys]
+      rest_kw_ty = sig_ret[:rest_kw_ty]
+      blk = sig_ret[:blk]
+      ret_ty = sig_ret[:ret_ty]
 
-        ret_ty = conv_type(ret_ty)
+      lead_tys = lead_tys.map {|ty| conv_type(ty) }
+      opt_tys = opt_tys.map {|ty| conv_type(ty) }
+      rest_ty = conv_type(rest_ty) if rest_ty
+      kw_tys = []
+      req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
+      opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
+      kw_rest_ty = conv_type(rest_kw_ty) if rest_kw_ty
 
-        blks.map do |blk|
-          [FormalArguments.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, blk), ret_ty]
-        end
-      end
+      blks = conv_block(blk)
 
-      TypedMethodDef.new(sig_rets, rbs_source)
+      ret_ty = conv_type(ret_ty)
+
+      blks.map do |blk|
+        [MethodSignature.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, blk), ret_ty]
+      end
     end
 
     def conv_block(blk)
@@ -552,9 +562,9 @@ module TypeProf
       req, lead_tys, opt_tys, ret_ty = blk
       lead_tys = lead_tys.map {|ty| conv_type(ty) }
       opt_tys = opt_tys.map {|ty| conv_type(ty) }
-      fargs = FormalArguments.new(lead_tys, opt_tys, nil, nil, nil, nil, nil)
+      msig = MethodSignature.new(lead_tys, opt_tys, nil, nil, nil, nil, nil)
       ret_ty = conv_type(ret_ty)
-      ret = [Type::TypedProc.new(fargs, ret_ty, Type::Builtin[:proc])]
+      ret = [Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Builtin[:proc])]
       ret << Type.nil unless req
       ret
     end
@@ -587,11 +597,23 @@ module TypeProf
           v_ty = conv_type(v)
           h[k_ty] = v_ty
         end
+      when :hash_record
+        _, path, key_tys = ty
+        Type.gen_hash(Type::Instance.new(path_to_klass(path))) do |h|
+          key_tys.each do |key, ty|
+            k_ty = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
+            v_ty = conv_type(ty)
+            h[k_ty] = v_ty
+          end
+        end
       when :union
         tys = ty[1]
         Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
+      when :proc
+        msig, ret_ty = conv_func(ty[1]).first # Currently, RBS Proc does not accept a block, so the size should be always one
+        Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Instance.new(Type::Builtin[:proc]))
       else
         pp ty
         raise NotImplementedError

data/lib/typeprof/iseq.rb

@@ -32,7 +32,8 @@ module TypeProf
         @name, @path, @absolute_path, @start_lineno, @type,
         @locals, @fargs_format, catch_table, insns = *iseq
 
-      if @type == :method
+      case @type
+      when :method, :block
         if @fargs_format[:opt]
           label = @fargs_format[:opt].last
           i = insns.index(label) + 1
@@ -45,7 +46,7 @@ module TypeProf
           label = insns[i + 1][1]
           i = insns.index(label) + 1
         end
-        insns[i, 0] = [[:_method_body]]
+        insns[i, 0] = [[:_iseq_body_start]]
       end
 
       @insns = []
@@ -216,6 +217,30 @@ module TypeProf
         @insns[j + 1] = [:send_branch, [getlocal_operands, send_operands, branch_operands]]
       end
 
+      # find a pattern: getlocal, dup, branch
+      (@insns.size - 2).times do |i|
+        next if branch_targets[i + 1] || branch_targets[i + 2]
+        insn0, getlocal_operands = @insns[i]
+        insn1, dup_operands = @insns[i + 1]
+        insn2, branch_operands = @insns[i + 2]
+        if insn0 == :getlocal && insn1 == :dup && insn2 == :branch && getlocal_operands[1] == 0
+          @insns[i    ] = [:nop]
+          @insns[i + 1] = [:nop]
+          @insns[i + 2] = [:getlocal_dup_branch, [getlocal_operands, dup_operands, branch_operands]]
+        end
+      end
+
+      # find a pattern: dup, branch
+      (@insns.size - 1).times do |i|
+        next if branch_targets[i + 1]
+        insn0, dup_operands = @insns[i]
+        insn1, branch_operands = @insns[i + 1]
+        if insn0 == :dup && insn1 == :branch
+          @insns[i    ] = [:nop]
+          @insns[i + 1] = [:dup_branch, [dup_operands, branch_operands]]
+        end
+      end
+
       # find a pattern: getlocal, branch
       (@insns.size - 1).times do |i|
         next if branch_targets[i + 1]

data/lib/typeprof/method.rb

@@ -14,21 +14,54 @@ module TypeProf
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
-      aargs.each_formal_arguments(@iseq.fargs_format) do |fargs, start_pc|
-        if fargs.is_a?(String)
-          scratch.error(caller_ep, fargs)
-          ctn[Type.any, caller_ep, caller_env]
-          next
-        end
+      locals = [Type.nil] * @iseq.locals.size
+
+      blk_ty, start_pcs = aargs.setup_formal_arguments(:method, locals, @iseq.fargs_format)
+      if blk_ty.is_a?(String)
+        scratch.error(caller_ep, blk_ty)
+        ctn[Type.any, caller_ep, caller_env]
+        return
+      end
 
-        callee_ep = do_send_core(fargs, start_pc, recv, mid, scratch)
+      nctx = Context.new(@iseq, @cref, mid)
+      callee_ep = ExecutionPoint.new(nctx, 0, nil)
+      nenv = Env.new(StaticEnv.new(recv, blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      alloc_site = AllocationSite.new(callee_ep)
+      locals.each_with_index do |ty, i|
+        alloc_site2 = alloc_site.add_id(i)
+        # nenv is top-level, so it is okay to call Type#localize directly
+        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv = nenv.local_update(i, ty)
+      end
 
-        scratch.add_iseq_method_call!(self, callee_ep.ctx)
-        scratch.add_callsite!(callee_ep.ctx, caller_ep, caller_env, &ctn)
+      start_pcs.each do |start_pc|
+        scratch.merge_env(ExecutionPoint.new(nctx, start_pc, @outer_ep), nenv)
       end
+
+      scratch.add_iseq_method_call!(self, nctx)
+      scratch.add_callsite!(nctx, caller_ep, caller_env, &ctn)
     end
 
-    def do_send_core(fargs, start_pc, recv, mid, scratch)
+    def do_check_send(msig, recv, mid, ep, scratch)
+      lead_num = @iseq.fargs_format[:lead_num] || 0
+      post_num = @iseq.fargs_format[:post_num] || 0
+      rest_start = @iseq.fargs_format[:rest_start]
+      opt = @iseq.fargs_format[:opt] || [0]
+
+      # TODO: check keywords
+      if rest_start
+        # almost ok
+      else
+        if msig.lead_tys.size + msig.post_tys.size < lead_num + post_num
+          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at least %d arguments" % [msig.lead_tys.size + msig.post_tys.size, lead_num + post_num])
+          return
+        end
+        if msig.lead_tys.size + msig.opt_tys.size + msig.post_tys.size > lead_num + opt.size - 1 + post_num
+          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at most %d arguments" % [msig.lead_tys.size + msig.opt_tys.size + msig.post_tys.size, lead_num + opt.size - 1 + post_num])
+          return
+        end
+      end
+
       lead_num = @iseq.fargs_format[:lead_num] || 0
       post_start = @iseq.fargs_format[:post_start]
       rest_start = @iseq.fargs_format[:rest_start]
@@ -37,81 +70,61 @@ module TypeProf
       kw_rest = @iseq.fargs_format[:kwrest]
       block_start = @iseq.fargs_format[:block_start]
 
-      # XXX: need to check .rbs fargs and .rb fargs
+      # XXX: need to check .rbs msig and .rb fargs
 
       ctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(ctx, start_pc, nil)
+      callee_ep = ExecutionPoint.new(ctx, 0, nil)
 
       locals = [Type.nil] * @iseq.locals.size
-      nenv = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       idx = 0
-      fargs.lead_tys.each_with_index do |ty, i|
+      msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
         # nenv is top-level, so it is okay to call Type#localize directly
         nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(i, ty)
       end
-      if fargs.opt_tys
-        fargs.opt_tys.each_with_index do |ty, i|
+      if msig.opt_tys
+        msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(lead_num + i, ty)
         end
       end
-      if fargs.rest_ty
+      if msig.rest_ty
         alloc_site2 = alloc_site.add_id(idx += 1)
-        ty = Type::Array.new(Type::Array::Elements.new([], fargs.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
+        ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
         nenv, rest_ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(rest_start, rest_ty)
       end
-      if fargs.post_tys
-        fargs.post_tys.each_with_index do |ty, i|
+      if msig.post_tys
+        msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
-      if fargs.kw_tys
-        fargs.kw_tys.each_with_index do |(_, key, ty), i|
+      if msig.kw_tys
+        msig.kw_tys.each_with_index do |(_, key, ty), i|
           alloc_site2 = alloc_site.add_id(key)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
-      if fargs.kw_rest_ty
-        ty = fargs.kw_rest_ty
+      if msig.kw_rest_ty
+        ty = msig.kw_rest_ty
         alloc_site2 = alloc_site.add_id(:**)
         nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(kw_rest, ty)
       end
-      nenv = nenv.local_update(block_start, fargs.blk_ty) if block_start
-
-      scratch.merge_env(callee_ep, nenv)
-
-      callee_ep
-    end
-
-    def do_check_send_core(fargs, recv, mid, ep, scratch)
-      lead_num = @iseq.fargs_format[:lead_num] || 0
-      post_num = @iseq.fargs_format[:post_num] || 0
-      rest_start = @iseq.fargs_format[:rest_start]
-      opt = @iseq.fargs_format[:opt] || [0]
+      nenv = nenv.local_update(block_start, msig.blk_ty) if block_start
 
-      # TODO: check keywords
-      if rest_start
-        # almost ok
-      else
-        if fargs.lead_tys.size + fargs.post_tys.size < lead_num + post_num
-          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at least %d arguments" % [fargs.lead_tys.size + fargs.post_tys.size, lead_num + post_num])
-          return
-        end
-        if fargs.lead_tys.size + fargs.opt_tys.size + fargs.post_tys.size > lead_num + opt.size - 1 + post_num
-          scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at most %d arguments" % [fargs.lead_tys.size + fargs.opt_tys.size + fargs.post_tys.size, lead_num + opt.size - 1 + post_num])
-          return
-        end
+      opt.each do |start_pc|
+        scratch.merge_env(ExecutionPoint.new(ctx, start_pc, nil), nenv)
       end
-      do_send_core(fargs, 0, recv, mid, scratch)
+
+      ctx
     end
   end
 
@@ -147,8 +160,8 @@ module TypeProf
   end
 
   class TypedMethodDef < MethodDef
-    def initialize(sigs, rbs_source) # sigs: Array<[FormalArguments, (return)Type]>
-      @sigs = sigs
+    def initialize(sig_rets, rbs_source) # sig_rets: Array<[MethodSignature, (return)Type]>
+      @sig_rets = sig_rets
       @rbs_source = rbs_source
     end
 
@@ -158,12 +171,12 @@ module TypeProf
       recv = scratch.globalize_type(recv_orig, caller_env, caller_ep)
       found = false
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
-      @sigs.each do |fargs, ret_ty|
+      @sig_rets.each do |msig, ret_ty|
         ncaller_env = caller_env
-        #pp [mid, aargs, fargs]
-        # XXX: support self type in fargs
+        #pp [mid, aargs, msig]
+        # XXX: support self type in msig
         subst = { Type::Var.new(:self) => recv }
-        next unless aargs.consistent_with_formal_arguments?(fargs, subst)
+        next unless aargs.consistent_with_method_signature?(msig, subst)
         case
         when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
           tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
@@ -171,12 +184,12 @@ module TypeProf
             ty = subst[tyvar]
             if ty
               ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
-                Utils.array_update(elems, idx, elems[idx].union(ty))
+              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                elems.update(idx, ty)
               end
             end
           end
-          tyvars.zip(recv.elems) do |tyvar, elem|
+          tyvars.zip(recv.elems.elems) do |tyvar, elem|
             if subst[tyvar]
               subst[tyvar] = subst[tyvar].union(elem)
             else
@@ -188,11 +201,11 @@ module TypeProf
           if subst[tyvar_elem]
             ty = subst[tyvar_elem]
             ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
+            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
               elems.update(nil, ty)
             end
           end
-          subst.merge!({ tyvar_elem => recv.elems.squash })
+          subst.merge!({ tyvar_elem => recv.elems.squash_or_any })
         when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
           tyvar_k = Type::Var.new(:K)
           tyvar_v = Type::Var.new(:V)
@@ -203,18 +216,19 @@ module TypeProf
         end
         ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
         found = true
-        if aargs.blk_ty.is_a?(Type::ISeqProc)
+        if aargs.blk_ty.is_a?(Type::Proc)
+          #raise NotImplementedError unless aargs.blk_ty.block_body.is_a?(ISeqBlock) # XXX
           dummy_ctx = TypedContext.new(caller_ep, mid)
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
-          dummy_env = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), [], [], Utils::HashWrapper.new({}))
-          if fargs.blk_ty.is_a?(Type::TypedProc)
+          dummy_env = Env.new(StaticEnv.new(recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
+          if msig.blk_ty.is_a?(Type::Proc)
             scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
-            nfargs = fargs.blk_ty.fargs
+            nfargs = msig.blk_ty.block_body.msig
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
             nlead_tys = (nfargs.lead_tys + nfargs.opt_tys).map.with_index do |ty, i|
               if recv.is_a?(Type::Array)
                 tyvar_elem = Type::Var.new(:Elem)
-                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash }), Config.options[:type_depth_limit])
+                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash_or_any }), Config.options[:type_depth_limit])
               else
                 ty = ty.substitute(subst, Config.options[:type_depth_limit])
               end
@@ -225,13 +239,13 @@ module TypeProf
             end
             0.upto(nfargs.opt_tys.size) do |n|
               naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
-              scratch.do_invoke_block(false, aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
+              scratch.do_invoke_block(aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
                 subst2 = {}
-                if blk_ret_ty.consistent?(fargs.blk_ty.ret_ty, subst2)
+                if blk_ret_ty.consistent?(msig.blk_ty.block_body.ret_ty, subst2)
                   if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
                     tyvar_elem = Type::Var.new(:Elem)
                     if subst2[tyvar_elem]
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
+                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
                         elems.update(nil, subst2[tyvar_elem])
                       end
                       scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
@@ -247,10 +261,10 @@ module TypeProf
                 end
                 ret_ty = ret_ty.remove_type_vars
                 # XXX: check the return type from the block
-                # sig.blk_ty.ret_ty.eql?(_ret_ty) ???
-                scratch.add_return_type!(dummy_ctx, ret_ty)
+                # sig.blk_ty.block_body.ret_ty.eql?(_ret_ty) ???
+                scratch.add_return_value!(dummy_ctx, ret_ty)
               end
-              # scratch.add_return_type!(dummy_ctx, ret_ty) ?
+              # scratch.add_return_value!(dummy_ctx, ret_ty) ?
               # This makes `def foo; 1.times { return "str" }; end` return Integer|String
             end
           else
@@ -273,8 +287,8 @@ module TypeProf
 
     def do_match_iseq_mdef(iseq_mdef, recv, mid, env, ep, scratch)
       recv = scratch.globalize_type(recv, env, ep)
-      @sigs.each do |fargs, _ret_ty|
-        iseq_mdef.do_check_send_core(fargs, recv, mid, ep, scratch)
+      @sig_rets.each do |msig, _ret_ty|
+        iseq_mdef.do_check_send(msig, recv, mid, ep, scratch)
       end
     end
   end