typeprof 0.1.0

data/lib/typeprof/insns-def.rb

@@ -0,0 +1,61 @@
+TypeProf::INSN_TABLE = {:nop=>[],
+ :getlocal=>["lindex_t", "rb_num_t"],
+ :setlocal=>["lindex_t", "rb_num_t"],
+ :getblockparam=>["lindex_t", "rb_num_t"],
+ :setblockparam=>["lindex_t", "rb_num_t"],
+ :getblockparamproxy=>["lindex_t", "rb_num_t"],
+ :getspecial=>["rb_num_t", "rb_num_t"],
+ :setspecial=>["rb_num_t"],
+ :getinstancevariable=>["ID", "IVC"],
+ :setinstancevariable=>["ID", "IVC"],
+ :getclassvariable=>["ID"],
+ :setclassvariable=>["ID"],
+ :getconstant=>["ID"],
+ :setconstant=>["ID"],
+ :getglobal=>["GENTRY"],
+ :setglobal=>["GENTRY"],
+ :putnil=>[],
+ :putself=>[],
+ :putobject=>["VALUE"],
+ :putspecialobject=>["rb_num_t"],
+ :putstring=>["VALUE"],
+ :concatstrings=>["rb_num_t"],
+ :tostring=>[],
+ :freezestring=>["VALUE"],
+ :toregexp=>["rb_num_t", "rb_num_t"],
+ :intern=>[],
+ :newarray=>["rb_num_t"],
+ :newarraykwsplat=>["rb_num_t"],
+ :duparray=>["VALUE"],
+ :duphash=>["VALUE"],
+ :expandarray=>["rb_num_t", "rb_num_t"],
+ :concatarray=>[],
+ :splatarray=>["VALUE"],
+ :newhash=>["rb_num_t"],
+ :newrange=>["rb_num_t"],
+ :pop=>[],
+ :dup=>[],
+ :dupn=>["rb_num_t"],
+ :swap=>[],
+ :reverse=>["rb_num_t"],
+ :topn=>["rb_num_t"],
+ :setn=>["rb_num_t"],
+ :adjuststack=>["rb_num_t"],
+ :defined=>["rb_num_t", "VALUE", "VALUE"],
+ :checkmatch=>["rb_num_t"],
+ :checkkeyword=>["lindex_t", "lindex_t"],
+ :checktype=>["rb_num_t"],
+ :defineclass=>["ID", "ISEQ", "rb_num_t"],
+ :definemethod=>["ID", "ISEQ"],
+ :definesmethod=>["ID", "ISEQ"],
+ :send=>["CALL_DATA", "ISEQ"],
+ :invokesuper=>["CALL_DATA", "ISEQ"],
+ :invokeblock=>["CALL_DATA"],
+ :leave=>[],
+ :throw=>["rb_num_t"],
+ :jump=>["OFFSET"],
+ :branchif=>["OFFSET"],
+ :branchunless=>["OFFSET"],
+ :branchnil=>["OFFSET"],
+ :once=>["ISEQ", "ISE"],
+ :invokebuiltin=>["RB_BUILTIN"]}

data/lib/typeprof/iseq.rb

@@ -0,0 +1,387 @@
+module TypeProf
+  class ISeq
+    include Utils::StructuralEquality
+
+    def self.compile(file)
+      opt = RubyVM::InstructionSequence.compile_option
+      opt[:inline_const_cache] = false
+      opt[:peephole_optimization] = false
+      opt[:specialized_instruction] = false
+      opt[:operands_unification] = false
+      opt[:coverage_enabled] = false
+      new(RubyVM::InstructionSequence.compile_file(file, **opt).to_a)
+    end
+
+    def self.compile_str(str, path = nil)
+      opt = RubyVM::InstructionSequence.compile_option
+      opt[:inline_const_cache] = false
+      opt[:peephole_optimization] = false
+      opt[:specialized_instruction] = false
+      opt[:operands_unification] = false
+      opt[:coverage_enabled] = false
+      new(RubyVM::InstructionSequence.compile(str, path, **opt).to_a)
+    end
+
+    FRESH_ID = [0]
+
+    def initialize(iseq)
+      @id = FRESH_ID[0]
+      FRESH_ID[0] += 1
+
+      _magic, _major_version, _minor_version, _format_type, _misc,
+        @name, @path, @absolute_path, @start_lineno, @type,
+        @locals, @fargs_format, catch_table, insns = *iseq
+
+      @insns = []
+      @linenos = []
+
+      labels = setup_iseq(insns)
+
+      # checkmatch->branch
+      # send->branch
+
+      @catch_table = []
+      catch_table.map do |type, iseq, first, last, cont, stack_depth|
+        iseq = iseq ? ISeq.new(iseq) : nil
+        entry = [type, iseq, labels[cont], stack_depth]
+        labels[first].upto(labels[last]) do |i|
+          @catch_table[i] ||= []
+          @catch_table[i] << entry
+        end
+      end
+
+      merge_branches
+
+      analyze_stack
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+
+    def setup_iseq(insns)
+      i = 0
+      labels = {}
+      insns.each do |e|
+        if e.is_a?(Symbol) && e.to_s.start_with?("label")
+          labels[e] = i
+        elsif e.is_a?(Array)
+          i += 1
+        end
+      end
+
+      lineno = 0
+      insns.each do |e|
+        case e
+        when Integer # lineno
+          lineno = e
+        when Symbol # label or trace
+          nil
+        when Array
+          insn, *operands = e
+          operands = INSN_TABLE[insn].zip(operands).map do |type, operand|
+            case type
+            when "ISEQ"
+              operand && ISeq.new(operand)
+            when "lindex_t", "rb_num_t", "VALUE", "ID", "GENTRY", "CALL_DATA"
+              operand
+            when "OFFSET"
+              labels[operand] || raise("unknown label: #{ operand }")
+            when "IVC", "ISE"
+              raise unless operand.is_a?(Integer)
+              :_cache_operand
+            else
+              raise "unknown operand type: #{ type }"
+            end
+          end
+
+          @insns << [insn, operands]
+          @linenos << lineno
+        else
+          raise "unknown iseq entry: #{ e }"
+        end
+      end
+
+      @fargs_format[:opt] = @fargs_format[:opt].map {|l| labels[l] } if @fargs_format[:opt]
+
+      labels
+    end
+
+    def merge_branches
+      @insns.size.times do |i|
+        insn, operands = @insns[i]
+        case insn
+        when :branchif
+          @insns[i] = [:branch, [:if] + operands]
+        when :branchunless
+          @insns[i] = [:branch, [:unless] + operands]
+        when :branchnil
+          @insns[i] = [:branch, [:nil] + operands]
+        end
+      end
+    end
+
+    def source_location(pc)
+      "#{ @path }:#{ @linenos[pc] }"
+    end
+
+    attr_reader :name, :path, :abolute_path, :start_lineno, :type, :locals, :fargs_format, :catch_table, :insns, :linenos
+    attr_reader :id
+
+    def pretty_print(q)
+      q.text "ISeq["
+      q.group do
+        q.nest(1) do
+          q.breakable ""
+          q.text "@type=          #{ @type }"
+          q.breakable ", "
+          q.text "@name=          #{ @name }"
+          q.breakable ", "
+          q.text "@path=          #{ @path }"
+          q.breakable ", "
+          q.text "@absolute_path= #{ @absolute_path }"
+          q.breakable ", "
+          q.text "@start_lineno=  #{ @start_lineno }"
+          q.breakable ", "
+          q.text "@fargs_format=  #{ @fargs_format.inspect }"
+          q.breakable ", "
+          q.text "@insns="
+          q.group(2) do
+            @insns.each_with_index do |(insn, *operands), i|
+              q.breakable
+              q.group(2, "#{ i }: #{ insn.to_s }", "") do
+                q.pp operands
+              end
+            end
+          end
+        end
+        q.breakable
+      end
+      q.text "]"
+    end
+
+    def analyze_stack
+      # gather branch targets
+      # TODO: catch_table should be also considered
+      branch_targets = {}
+      @insns.each do |insn, operands|
+        case insn
+        when :branch
+          branch_targets[operands[1]] = true
+        when :jump
+          branch_targets[operands[0]] = true
+        end
+      end
+
+      # find a pattern: getlocal, ..., send (is_a?, respond_to?), branch
+      send_branch_list = []
+      (@insns.size - 1).times do |i|
+        insn, operands = @insns[i]
+        if insn == :getlocal && operands[1] == 0
+          j = i + 1
+          sp = 1
+          while @insns[j]
+            sp = check_send_branch(sp, j)
+            if sp == :match
+              send_branch_list << [i, j]
+              break
+            end
+            break if !sp
+            j += 1
+          end
+        end
+      end
+      send_branch_list.each do |i, j|
+        next if (i + 1 .. j).any? {|i| branch_targets[i] }
+        _insn, getlocal_operands = @insns[i]
+        _insn, send_operands = @insns[j]
+        _insn, branch_operands = @insns[j + 1]
+        @insns[j] = [:nop]
+        @insns[j + 1] = [:send_branch, [getlocal_operands, send_operands, branch_operands]]
+      end
+
+      # find a pattern: getlocal, branch
+      (@insns.size - 1).times do |i|
+        next if branch_targets[i + 1]
+        insn0, getlocal_operands = @insns[i]
+        insn1, branch_operands = @insns[i + 1]
+        if [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0 && insn1 == :branch
+          @insns[i    ] = [:nop]
+          @insns[i + 1] = [:getlocal_branch, [getlocal_operands, branch_operands]]
+        end
+      end
+
+      # flow-sensitive analysis for `case var; when A; when B; when C; end`
+      # find a pattern: getlocal, (dup, putobject(true), getconstant(class name), checkmatch, branch)*
+      case_branch_list = []
+      (@insns.size - 1).times do |i|
+        insn0, getlocal_operands = @insns[i]
+        next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
+        nops = [i]
+        new_insns = []
+        j = i + 1
+        while true
+          case @insns[j]
+          when [:dup, []]
+            break unless @insns[j + 1] == [:putnil, []]
+            break unless @insns[j + 2] == [:putobject, [true]]
+            break unless @insns[j + 3][0] == :getconstant # TODO: support A::B::C
+            break unless @insns[j + 4] == [:checkmatch, [2]]
+            break unless @insns[j + 5][0] == :branch
+            target_pc = @insns[j + 5][1][1]
+            break unless @insns[target_pc] == [:pop, []]
+            nops << j << (j + 4) << target_pc
+            new_insns << [j + 5, [:getlocal_checkmatch_branch, [getlocal_operands, @insns[j + 5][1]]]]
+            j += 6
+          when [:pop, []]
+            nops << j
+            case_branch_list << [nops, new_insns]
+            break
+          else
+            break
+          end
+        end
+      end
+      case_branch_list.each do |nops, new_insns|
+        nops.each {|i| @insns[i] = [:nop, []] }
+        new_insns.each {|i, insn| @insns[i] = insn }
+      end
+    end
+
+    def check_send_branch(sp, j)
+      insn, operands = @insns[j]
+
+      case insn
+      when :putspecialobject, :putnil, :putobject, :duparray, :putstring,
+           :putself
+        sp += 1
+      when :newarray, :newarraykwsplat, :newhash, :concatstrings
+        len, = operands
+        sp =- len
+        return nil if sp <= 0
+        sp += 1
+      when :newhashfromarray
+        raise NotImplementedError, "newhashfromarray"
+      when :newrange, :tostring
+        sp -= 2
+        return nil if sp <= 0
+        sp += 1
+      when :freezestring
+        # XXX: should leverage this information?
+      when :toregexp
+        _regexp_opt, len = operands
+        sp -= len
+        return nil if sp <= 0
+        sp += 1
+      when :intern
+        sp -= 1
+        return nil if sp <= 0
+        sp += 1
+      when :definemethod, :definesmethod
+      when :defineclass
+        sp -= 2
+      when :send, :invokesuper
+        opt, = operands
+        _flags = opt[:flag]
+        _mid = opt[:mid]
+        kw_arg = opt[:kw_arg]
+        argc = opt[:orig_argc]
+        argc += 1 # receiver
+        argc += kw_arg.size if kw_arg
+        sp -= argc
+        return :match if insn == :send && sp == 0 && @insns[j + 1][0] == :branch
+        sp += 1
+      when :invokeblock
+        opt, = operands
+        sp -= opt[:orig_argc]
+        return nil if sp <= 0
+        sp += 1
+      when :invokebuiltin
+        raise NotImplementedError
+      when :leave, :throw
+        return
+      when :once
+        return # not implemented
+      when :branch, :jump
+        return # not implemented
+      when :setinstancevariable, :setclassvariable, :setglobal
+        sp -= 1
+      when :setlocal, :setblockparam
+        return # conservative
+      when :getinstancevariable, :getclassvariable, :getglobal,
+           :getlocal, :getblockparam, :getblockparamproxy
+        sp += 1
+      when :getconstant
+        sp -= 2
+        return nil if sp <= 0
+        sp += 1
+      when :setconstant
+        sp -= 2
+      when :getspecial
+        sp += 1
+      when :setspecial
+        # flip-flop
+        raise NotImplementedError, "setspecial"
+      when :dup
+        sp += 1
+      when :duphash
+        sp += 1
+      when :dupn
+        n, = operands
+        sp += n
+      when :pop
+        sp -= 1
+      when :swap
+        sp -= 2
+        return nil if sp <= 0
+        sp += 2
+      when :reverse
+        n, = operands
+        sp -= n
+        return nil if sp <= 0
+        sp += n
+      when :defined
+        sp -= 1
+        return nil if sp <= 0
+        sp += 1
+      when :checkmatch
+        sp -= 2
+        return nil if sp <= 0
+        sp += 1
+      when :checkkeyword
+        sp += 1
+      when :adjuststack
+        n, = operands
+        sp -= n
+      when :nop
+      when :setn
+        return nil # not implemented
+      when :topn
+        sp += 1
+      when :splatarray
+        sp -= 1
+        return nil if sp <= 0
+        sp += 1
+      when :expandarray
+        num, flag = operands
+        splat = flag & 1 == 1
+        sp -= 1
+        return nil if sp <= 0
+        sp += num + (splat ? 1 : 0)
+      when :concatarray
+        sp -= 2
+        return nil if sp <= 0
+        sp += 1
+      when :checktype
+        sp -= 1
+        return nil if sp <= 0
+        sp += 1
+      else
+        raise "Unknown insn: #{ insn }"
+      end
+
+      return nil if sp <= 0
+      sp
+    end
+  end
+end

data/lib/typeprof/method.rb

@@ -0,0 +1,267 @@
+module TypeProf
+  class MethodDef
+    include Utils::StructuralEquality
+  end
+
+  class ISeqMethodDef < MethodDef
+    def initialize(iseq, cref)
+      @iseq = iseq
+      raise if iseq.nil?
+      @cref = cref
+    end
+
+    def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      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
+
+        callee_ep = do_send_core(fargs, start_pc, recv, mid, scratch)
+
+        scratch.add_iseq_method_call!(self, callee_ep.ctx)
+        scratch.add_callsite!(callee_ep.ctx, fargs, caller_ep, caller_env, &ctn)
+      end
+    end
+
+    def do_send_core(fargs, start_pc, recv, mid, scratch)
+      lead_num = @iseq.fargs_format[:lead_num] || 0
+      post_start = @iseq.fargs_format[:post_start]
+      rest_start = @iseq.fargs_format[:rest_start]
+      kw_start = @iseq.fargs_format[:kwbits]
+      kw_start -= @iseq.fargs_format[:keyword].size if kw_start
+      block_start = @iseq.fargs_format[:block_start]
+
+      # XXX: need to check .rbs fargs and .rb fargs
+
+      ctx = Context.new(@iseq, @cref, mid) # XXX: to support opts, rest, etc
+      callee_ep = ExecutionPoint.new(ctx, start_pc, nil)
+
+      locals = [Type.nil] * @iseq.locals.size
+      nenv = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      alloc_site = AllocationSite.new(callee_ep)
+      idx = 0
+      fargs.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|
+          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
+        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]))
+        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|
+          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 |(_, _, 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(kw_start + i, ty)
+        end
+      end
+      # kwrest
+      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]
+
+      # 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
+      end
+      do_send_core(fargs, 0, recv, mid, scratch)
+    end
+  end
+
+  class AttrMethodDef < MethodDef
+    def initialize(ivar, kind)
+      @ivar = ivar
+      @kind = kind # :reader | :writer
+    end
+
+    attr_reader :ivar, :kind
+
+    def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      case @kind
+      when :reader
+        if aargs.lead_tys.size == 0
+          scratch.get_instance_variable(recv, @ivar, caller_ep, caller_env) do |ty, nenv|
+            ctn[ty, caller_ep, nenv]
+          end
+        else
+          ctn[Type.any, caller_ep, caller_env]
+        end
+      when :writer
+        if aargs.lead_tys.size == 1
+          ty = aargs.lead_tys[0]
+          scratch.set_instance_variable(recv, @ivar, ty, caller_ep, caller_env)
+          ctn[ty, caller_ep, caller_env]
+        else
+          ctn[Type.any, caller_ep, caller_env]
+        end
+      end
+    end
+  end
+
+  class TypedMethodDef < MethodDef
+    def initialize(sigs, rbs_source) # sigs: Array<[FormalArguments, (return)Type]>
+      @sigs = sigs
+      @rbs_source = rbs_source
+    end
+
+    attr_reader :rbs_source
+
+    def do_send(recv_orig, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      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|
+        ncaller_env = caller_env
+        # XXX: need to interpret args more correctly
+        #pp [mid, aargs, fargs]
+        # XXX: support self type in fargs
+        subst = { Type::Var.new(:self) => recv }
+        next unless aargs.consistent_with_formal_arguments?(fargs, subst)
+        if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+          tyvar_elem = Type::Var.new(:Elem)
+          if subst[tyvar_elem]
+            ty = subst[tyvar_elem]
+            alloc_site = AllocationSite.new(caller_ep).add_id(self)
+            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|
+              elems.update(nil, ty)
+            end
+          end
+          subst.merge!({ tyvar_elem => recv.elems.squash })
+        elsif recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+          tyvar_k = Type::Var.new(:K)
+          tyvar_v = Type::Var.new(:V)
+          # XXX: need to support destructive operation
+          k_ty, v_ty = recv.elems.squash
+          # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
+          subst.merge!({ tyvar_k => k_ty, tyvar_v => v_ty })
+        end
+        ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
+        found = true
+        if aargs.blk_ty.is_a?(Type::ISeqProc)
+          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)
+            scratch.add_callsite!(dummy_ctx, nil, caller_ep, ncaller_env, &ctn)
+            nfargs = fargs.blk_ty.fargs
+            alloc_site = AllocationSite.new(caller_ep).add_id(self)
+            nfargs = nfargs.map.with_index do |nfarg, i|
+              if recv.is_a?(Type::Array)
+                tyvar_elem = Type::Var.new(:Elem)
+                nfarg = nfarg.substitute(subst.merge({ tyvar_elem => recv.elems.squash }), Config.options[:type_depth_limit])
+              else
+                nfarg = nfarg.substitute(subst, Config.options[:type_depth_limit])
+              end
+              nfarg = nfarg.remove_type_vars
+              alloc_site2 = alloc_site.add_id(i)
+              dummy_env, nfarg = scratch.localize_type(nfarg, dummy_env, dummy_ep, alloc_site2)
+              nfarg
+            end
+            naargs = ActualArguments.new(nfargs, nil, 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|
+              subst2 = {}
+              if blk_ret_ty.consistent?(fargs.blk_ty.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|
+                      elems.update(nil, subst2[tyvar_elem])
+                    end
+                    scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                  end
+                  ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                else
+                  ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                end
+              else
+                # raise "???"
+                # XXX: need warning
+                ret_ty = Type.any
+              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)
+            end
+            # scratch.add_return_type!(dummy_ctx, ret_ty) ?
+            # This makes `def foo; 1.times { return "str" }; end` return Integer|String
+          else
+            # XXX: a block is passed to a method that does not accept block.
+            # Should we call the passed block with any arguments?
+            ret_ty = ret_ty.remove_type_vars
+            ctn[ret_ty, caller_ep, ncaller_env]
+          end
+        else
+          ret_ty = ret_ty.remove_type_vars
+          ctn[ret_ty, caller_ep, ncaller_env]
+        end
+      end
+
+      unless found
+        scratch.error(caller_ep, "failed to resolve overload: #{ recv.screen_name(scratch) }##{ mid }")
+        ctn[Type.any, caller_ep, caller_env]
+      end
+    end
+
+    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)
+      end
+    end
+  end
+
+  class CustomMethodDef < MethodDef
+    def initialize(impl)
+      @impl = impl
+    end
+
+    def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      # XXX: ctn?
+      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env } # for Kernel#lambda
+      @impl[recv, mid, aargs, caller_ep, caller_env, scratch, &ctn]
+    end
+  end
+end