typeprof 0.12.0 → 0.15.0

data/lib/typeprof/block.rb

@@ -27,7 +27,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       blk_env = scratch.return_envs[@outer_ep]
       if replace_recv_ty
         replace_recv_ty = scratch.globalize_type(replace_recv_ty, caller_env, caller_ep)
@@ -46,7 +46,8 @@ module TypeProf
         return
       end
 
-      nctx = Context.new(@iseq, @outer_ep.ctx.cref, nil)
+      cref = replace_cref || @outer_ep.ctx.cref
+      nctx = Context.new(@iseq, cref, nil)
       callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
       nenv = Env.new(blk_env.static_env, locals, [], nil)
       alloc_site = AllocationSite.new(callee_ep)
@@ -87,7 +88,7 @@ module TypeProf
       TypedBlock.new(msig, ret_ty)
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
       subst = aargs.consistent_with_method_signature?(@msig)
       unless subst
@@ -119,7 +120,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       if aargs.lead_tys.size >= 1
         recv = aargs.lead_tys[0]
         recv = Type.any if recv == Type.bot
@@ -157,7 +158,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
       dummy_ctx = TypedContext.new(@caller_ep, @mid)
@@ -165,7 +166,7 @@ module TypeProf
       scratch.add_block_signature!(self, aargs.to_block_signature)
       scratch.add_block_to_ctx!(self, dummy_ctx)
 
-      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty) do |ret_ty, ep, env|
+      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty, replace_cref: replace_cref) do |ret_ty, ep, env|
         scratch.add_return_value!(dummy_ctx, ret_ty)
         ctn[ret_ty, ep, env]
       end

data/lib/typeprof/builtin.rb

@@ -73,9 +73,9 @@ module TypeProf
       else
         ty = Type::Instance.new(recv)
       end
-      meths = scratch.get_method(recv, false, :initialize)
+      meths = scratch.get_method(recv, false, false, :initialize)
       meths.flat_map do |meth|
-        meth.do_send(ty, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
+        meth.do_send(ty, :initialize, aargs, ep, env, scratch) do |_ret_ty, ep, env|
           ctn[ty, ep, env]
         end
       end
@@ -104,7 +104,7 @@ module TypeProf
         sym = get_sym("respond_to?", aargs.lead_tys[0], ep, scratch)
         if sym
           klass, singleton = recv.method_dispatch_info
-          if scratch.get_method(klass, singleton, sym)
+          if scratch.get_method(klass, singleton, false, sym)
             true_val = Type::Instance.new(Type::Builtin[:true])
             ctn[true_val, ep, env]
           else
@@ -158,7 +158,43 @@ module TypeProf
       naargs = ActualArguments.new([recv], nil, {}, Type.nil)
       nrecv = recv
       nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
-      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |_ret_ty, ep|
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |ret_ty, ep|
+        ctn[ret_ty, ep, env]
+      end
+    end
+
+    def module_eqq(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size == 1
+        aargs.lead_tys[0].each_child do |aarg|
+          aarg = aarg.base_type if aarg.is_a?(Type::Symbol) # XXX
+          if aarg.is_a?(Type::Instance)
+            if aarg.klass == recv # XXX: inheritance
+              true_val = Type::Instance.new(Type::Builtin[:true])
+              ctn[true_val, ep, env]
+            else
+              false_val = Type::Instance.new(Type::Builtin[:false])
+              ctn[false_val, ep, env]
+            end
+          else
+            ctn[Type.bool, ep, env]
+          end
+        end
+      else
+        ctn[Type.bool, ep, env]
+      end
+    end
+
+    def object_module_eval(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        scratch.warn(ep, "class_eval with arguments is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+      naargs = ActualArguments.new([recv], nil, {}, Type.nil)
+      nrecv = recv
+      nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
+      ncref = ep.ctx.cref.extend(nrecv, true)
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv, replace_cref: ncref) do |_ret_ty, ep|
         ctn[recv, ep, env]
       end
     end
@@ -176,7 +212,7 @@ module TypeProf
       end
 
       elem_ty = Type.bot
-      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &blk_ctn|
+      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &blk_ctn|
         if aargs.lead_tys.size >= 1
           elem_ty = elem_ty.union(aargs.lead_tys[0])
         else
@@ -235,9 +271,12 @@ module TypeProf
         return ctn[Type.any, ep, env]
       end
 
+      # support multiple arguments: include M1, M2
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :included, aargs, ep, env) {|_ret_ty, _ep| }
           scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
@@ -259,6 +298,8 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :extended, aargs, ep, env) {|_ret_ty, _ep| }
           # if ep.ctx.cref.singleton is true, the meta-meta level is ignored. Should we warn?
           scratch.mix_module(:after, recv, arg, nil, true, ep)
         end
@@ -293,7 +334,7 @@ module TypeProf
       else
         aargs.lead_tys.each do |aarg|
           sym = get_sym("module_function", aarg, ep, scratch) or next
-          meths = scratch.get_method(recv, false, sym)
+          meths = scratch.get_method(recv, false, false, sym)
           meths.each do |mdef|
             scratch.add_method(recv, sym, true, mdef)
           end
@@ -309,7 +350,7 @@ module TypeProf
         if recv.is_a?(Type::Class)
           aargs.lead_tys.each do |aarg|
             sym = get_sym("public", aarg, ep, scratch) or next
-            meths = scratch.get_method(recv, false, sym)
+            meths = scratch.get_method(recv, false, false, sym)
             next unless meths
             meths.each do |mdef|
               mdef.pub_meth = true if mdef.respond_to?(:pub_meth=)
@@ -329,7 +370,7 @@ module TypeProf
         if recv.is_a?(Type::Class)
           aargs.lead_tys.each do |aarg|
             sym = get_sym("private", aarg, ep, scratch) or next
-            meths = scratch.get_method(recv, false, sym)
+            meths = scratch.get_method(recv, false, false, sym)
             next unless meths
             meths.each do |mdef|
               mdef.pub_meth = false if mdef.respond_to?(:pub_meth=)
@@ -594,9 +635,6 @@ module TypeProf
     end
 
     def self.file_require(feature, scratch)
-      return :done, :false if scratch.loaded_features[feature]
-      scratch.loaded_features[feature] = true
-
       # XXX: dynamic RBS load is really needed??  Another idea:
       #
       # * RBS should be loaded in advance of analysis
@@ -612,7 +650,11 @@ module TypeProf
 
       begin
         filetype, path = $LOAD_PATH.resolve_feature_path(feature)
+
         if filetype == :rb
+          return :done, :false if scratch.loaded_files[path]
+          scratch.loaded_files[path] = true
+
           return :do, path if File.readable?(path)
 
           return :error, "failed to load: #{ path }"
@@ -673,13 +715,14 @@ module TypeProf
           return ctn[Type.any, ep, env]
         end
 
-        if scratch.loaded_features[feature]
+        path = File.join(File.dirname(ep.ctx.iseq.absolute_path), feature) + ".rb" # XXX
+
+        if scratch.loaded_files[path]
           result = Type::Instance.new(Type::Builtin[:false])
           return ctn[result, ep, env]
         end
-        scratch.loaded_features[feature] = true
+        scratch.loaded_files[path] = true
 
-        path = File.join(File.dirname(ep.ctx.iseq.path), feature) + ".rb" # XXX
         return Builtin.file_load(path, ep, env, scratch, &ctn) if File.readable?(path)
 
         scratch.warn(ep, "failed to load: #{ path }")
@@ -804,9 +847,12 @@ module TypeProf
       scratch.set_custom_method(klass_module, :public, Builtin.method(:module_public), false)
       scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private), false)
       scratch.set_custom_method(klass_module, :define_method, Builtin.method(:module_define_method))
-      scratch.set_custom_method(klass_module, :"attr_accessor", Builtin.method(:module_attr_accessor))
-      scratch.set_custom_method(klass_module, :"attr_reader", Builtin.method(:module_attr_reader))
-      scratch.set_custom_method(klass_module, :"attr_writer", Builtin.method(:module_attr_writer))
+      scratch.set_custom_method(klass_module, :attr_accessor, Builtin.method(:module_attr_accessor))
+      scratch.set_custom_method(klass_module, :attr_reader, Builtin.method(:module_attr_reader))
+      scratch.set_custom_method(klass_module, :attr_writer, Builtin.method(:module_attr_writer))
+      scratch.set_custom_method(klass_module, :class_eval, Builtin.method(:object_module_eval))
+      scratch.set_custom_method(klass_module, :module_eval, Builtin.method(:object_module_eval))
+      scratch.set_custom_method(klass_module, :===, Builtin.method(:module_eqq))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))

data/lib/typeprof/cli.rb

@@ -64,6 +64,7 @@ module TypeProf
       opt.separator "Advanced options:"
       opt.on("--[no-]stub-execution", "Force to call all unreachable methods with \"untyped\" arguments") {|v| options[:stub_execution] = v }
       opt.on("--type-depth-limit DEPTH", Integer, "Limit the maximum depth of nested types") {|v| options[:type_depth_limit] = v }
+      opt.on("--union-width-limit WIDTH", Integer, "Limit the maximum count of class instances in one union type") {|v| options[:union_width_limit] = v }
       opt.on("--debug", "Display analysis log (for debugging purpose)") { verbose = 2 }
       opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| options[:stackprof] = v.to_sym }
 

data/lib/typeprof/config.rb

@@ -40,6 +40,7 @@ module TypeProf
         show_source_locations: false,
         stub_execution: true,
         type_depth_limit: 5,
+        union_width_limit: 10,
         stackprof: nil,
       }.merge(opt[:options])
       super(**opt)
@@ -80,21 +81,6 @@ module TypeProf
       Import.import_library(scratch, feature)
     end
 
-    prologue_ctx = Context.new(nil, nil, nil)
-    prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
-    prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
-
-    Config.rb_files.each do |rb|
-      if rb.is_a?(Array) # [String name, String content]
-        iseq = ISeq.compile_str(*rb.reverse)
-      else
-        iseq = ISeq.compile(rb)
-      end
-      ep, env = TypeProf.starting_state(iseq)
-      scratch.merge_env(ep, env)
-      scratch.add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
-    end
-
     rbs_files = []
     rbs_codes = []
     Config.rbs_files.each do |rbs|
@@ -109,6 +95,15 @@ module TypeProf
       Import.import_rbs_code(scratch, name, content)
     end
 
+    Config.rb_files.each do |rb|
+      if rb.is_a?(Array) # [String name, String content]
+        iseq = ISeq.compile_str(*rb.reverse)
+      else
+        iseq = rb
+      end
+      scratch.add_entrypoint(iseq)
+    end
+
     result = scratch.type_profile
 
     if Config.output.respond_to?(:write)

data/lib/typeprof/export.rb

@@ -137,19 +137,19 @@ module TypeProf
             ctxs = @iseq_method_to_ctxs[mdef]
             next unless ctxs
 
-            ctxs.each do |ctx|
-              next if mid != ctx.mid
-              next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+            ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first
 
-              method_name = ctx.mid
-              method_name = "self.#{ method_name }" if singleton
+            next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
 
-              key = [:iseq, method_name]
-              visibilities[key] ||= mdef.pub_meth
-              source_locations[key] ||= ctx.iseq.source_location(0)
-              (methods[key] ||= []) << @scratch.show_method_signature(ctx)
-            end
+            method_name = mid
+            method_name = "self.#{ method_name }" if singleton
+
+            key = [:iseq, method_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= ctx.iseq.source_location(0)
+            (methods[key] ||= []) << @scratch.show_method_signature(ctx)
           when AliasMethodDef
+            next if mdef.def_ep && Config.check_dir_filter(mdef.def_ep.source_location) == :exclude
             alias_name, orig_name = mid, mdef.orig_mid
             if singleton
               alias_name = "self.#{ alias_name }"

data/lib/typeprof/import.rb

@@ -189,11 +189,15 @@ module TypeProf
             when RBS::AST::Members::Include
               name = member.name
               if name.kind == :class
+                # including a module
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
                 modules[:include] << [mod, type_args]
               else
-                # including an interface is not supported yet
+                # including an interface
+                mod = conv_type_name(name)
+                type_args = member.args.map {|type| conv_type(type) }
+                modules[:include] << [mod, type_args]
               end
 
             when RBS::AST::Members::Extend
@@ -369,25 +373,30 @@ module TypeProf
     end
 
     def conv_block(rbs_block)
-      type = rbs_block.type
-
-      # XXX
-      raise NotImplementedError unless type.optional_keywords.empty?
-      raise NotImplementedError unless type.required_keywords.empty?
-      raise NotImplementedError if type.rest_keywords
+      blk = rbs_block.type
 
-      req = rbs_block.required
-
-      lead_tys = type.required_positionals.map do |type|
-        conv_type(type.type)
-      end
-      opt_tys = type.optional_positionals.map do |type|
-        conv_type(type.type)
-      end
+      lead_tys = blk.required_positionals.map {|type| conv_type(type.type) }
+      opt_tys = blk.optional_positionals.map {|type| conv_type(type.type) }
+      rest_ty = blk.rest_positionals
+      rest_ty = conv_type(rest_ty.type) if rest_ty
+      opt_kw_tys = blk.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      req_kw_tys = blk.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      rest_kw_ty = blk.rest_keywords
+      rest_kw_ty = conv_type(rest_kw_ty.type) if rest_kw_ty
 
-      ret_ty = conv_type(type.return_type)
+      ret_ty = conv_type(blk.return_type)
 
-      [req, lead_tys, opt_tys, ret_ty]
+      {
+        required_block: rbs_block.required,
+        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 conv_type(ty)
@@ -626,7 +635,13 @@ module TypeProf
       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
+      if rest_kw_ty
+        ty = conv_type(rest_kw_ty)
+        kw_rest_ty = Type.gen_hash do |h|
+          k_ty = Type::Instance.new(Type::Builtin[:sym])
+          h[k_ty] = ty
+        end
+      end
 
       blks = conv_block(blk)
 
@@ -639,13 +654,36 @@ module TypeProf
 
     def conv_block(blk)
       return [Type.nil] unless blk
-      req, lead_tys, opt_tys, ret_ty = blk
+
+      required_block = blk[:required_block]
+      lead_tys = blk[:lead_tys]
+      opt_tys = blk[:opt_tys]
+      rest_ty = blk[:rest_ty]
+      req_kw_tys = blk[:req_kw_tys]
+      opt_kw_tys = blk[:opt_kw_tys]
+      rest_kw_ty = blk[:rest_kw_ty]
+      ret_ty = blk[:ret_ty]
+
       lead_tys = lead_tys.map {|ty| conv_type(ty) }
       opt_tys = opt_tys.map {|ty| conv_type(ty) }
-      msig = MethodSignature.new(lead_tys, opt_tys, nil, [], {}, nil, Type.nil)
+      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)] }
+      if rest_kw_ty
+        ty = conv_type(rest_kw_ty)
+        kw_rest_ty = Type.gen_hash do |h|
+          k_ty = Type::Instance.new(Type::Builtin[:sym])
+          h[k_ty] = ty
+        end
+      end
+
+      msig = MethodSignature.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, Type.nil)
+
       ret_ty = conv_type(ret_ty)
+
       ret = [Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Builtin[:proc])]
-      ret << Type.nil unless req
+      ret << Type.nil unless required_block
       ret
     end
 
@@ -690,7 +728,7 @@ module TypeProf
         end
       when :union
         tys = ty[1]
-        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil).normalize # XXX: Array and Hash support
+        Type::Union.create(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
       when :proc

data/lib/typeprof/iseq.rb

@@ -1,5 +1,8 @@
 module TypeProf
   class ISeq
+    # https://github.com/ruby/ruby/pull/4468
+    CASE_WHEN_CHECKMATCH = RubyVM::InstructionSequence.compile("case 1; when Integer; end").to_a.last.any? {|insn,| insn == :checkmatch }
+
     include Utils::StructuralEquality
 
     def self.compile(file)
@@ -206,8 +209,76 @@ module TypeProf
         end
       end
 
-      # find a pattern: getlocal, ..., send (is_a?, respond_to?), branch
-      getlocal_send_branch_list = []
+      # 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)* for ..Ruby 3.0
+      # find a pattern: getlocal, (putobject(true), getconstant(class name), top(1), send(===), branch)* for Ruby 3.1..
+      case_branch_list = []
+      if CASE_WHEN_CHECKMATCH
+        (@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
+      else
+        (@insns.size - 1).times do |i|
+          insn0, getlocal_operands = @insns[i]
+          next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
+          nops = []
+          new_insns = []
+          j = i + 1
+          while true
+            case @insns[j]
+            when [:putnil, []]
+              break unless @insns[j + 1] == [:putobject, [true]]
+              break unless @insns[j + 2][0] == :getconstant # TODO: support A::B::C
+              break unless @insns[j + 3] == [:topn, [1]]
+              break unless @insns[j + 4] == [:send, [{:mid=>:===, :flag=>20, :orig_argc=>1}, nil]]
+              break unless @insns[j + 5][0] == :branch
+              target_pc = @insns[j + 5][1][1]
+              break unless @insns[target_pc] == [:pop, []]
+              nops << (j + 4) #<< target_pc
+              new_insns << [j + 5, [:arg_getlocal_send_branch, [getlocal_operands, @insns[j + 4][1], @insns[j + 5][1]]]]
+              j += 6
+            when [:pop, []]
+              #nops << j
+              case_branch_list << [nops, new_insns]
+              break
+            else
+              break
+            end
+          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
+
+      # find a pattern: getlocal(recv), ..., send (is_a?, respond_to?), branch
+      recv_getlocal_send_branch_list = []
       (@insns.size - 1).times do |i|
         insn, operands = @insns[i]
         if insn == :getlocal && operands[1] == 0
@@ -216,7 +287,7 @@ module TypeProf
           while @insns[j]
             sp = check_send_branch(sp, j)
             if sp == :match
-              getlocal_send_branch_list << [i, j]
+              recv_getlocal_send_branch_list << [i, j]
               break
             end
             break if !sp
@@ -224,13 +295,35 @@ module TypeProf
           end
         end
       end
-      getlocal_send_branch_list.each do |i, j|
+      recv_getlocal_send_branch_list.each do |i, j|
         next if (i + 1 .. j + 1).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] = [:getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
+        @insns[j + 1] = [:recv_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
+      end
+
+      # find a pattern: getlocal, send (===), branch
+      arg_getlocal_send_branch_list = []
+      (@insns.size - 1).times do |i|
+        insn1, operands1 = @insns[i]
+        next unless insn1 == :getlocal && operands1[1] == 0
+        insn2, operands2 = @insns[i + 1]
+        next unless insn2 == :send
+        send_opt = operands2[0]
+        next unless send_opt[:flag] == 16 && send_opt[:orig_argc] == 1
+        insn3, _operands3 = @insns[i + 2]
+        next unless insn3 == :branch
+        arg_getlocal_send_branch_list << i
+      end
+      arg_getlocal_send_branch_list.each do |i|
+        next if (i .. i + 2).any? {|i| branch_targets[i] }
+        _insn, getlocal_operands = @insns[i]
+        _insn, send_operands = @insns[i + 1]
+        _insn, branch_operands = @insns[i + 2]
+        @insns[i + 1] = [:nop]
+        @insns[i + 2] = [:arg_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
       end
 
       # find a pattern: send (block_given?), branch
@@ -286,42 +379,6 @@ module TypeProf
           @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)
@@ -367,6 +424,8 @@ module TypeProf
         sp -= argc
         return :match if insn == :send && sp == 0 && @insns[j + 1][0] == :branch
         sp += 1
+      when :arg_getlocal_send_branch
+        return # not implemented
       when :invokeblock
         opt, = operands
         sp -= opt[:orig_argc]