typeprof 0.14.1 → 0.15.3

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
@@ -334,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
@@ -350,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=)
@@ -370,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=)
@@ -635,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
@@ -653,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 }"
@@ -714,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 }")
@@ -811,6 +813,7 @@ module TypeProf
       Type::Builtin[:exc]        = scratch.get_constant(klass_obj, :Exception)
       Type::Builtin[:encoding]   = scratch.get_constant(klass_obj, :Encoding)
       Type::Builtin[:enumerator] = scratch.get_constant(klass_obj, :Enumerator)
+      Type::Builtin[:kernel]     = scratch.get_constant(klass_obj, :Kernel)
 
       klass_vmcore = Type::Builtin[:vmcore]
       klass_ary    = Type::Builtin[:ary]
@@ -823,6 +826,7 @@ module TypeProf
       scratch.set_custom_method(klass_vmcore, :"core#undef_method", Builtin.method(:vmcore_undef_method))
       scratch.set_custom_method(klass_vmcore, :"core#hash_merge_kwd", Builtin.method(:vmcore_hash_merge_kwd))
       scratch.set_custom_method(klass_vmcore, :"core#raise", Builtin.method(:vmcore_raise))
+
       scratch.set_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
       scratch.set_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
       scratch.set_custom_method(klass_obj, :p, Builtin.method(:kernel_p), false)
@@ -878,6 +882,12 @@ module TypeProf
       str_ty = Type::Instance.new(Type::Builtin[:str])
       env_ty = Type.gen_hash {|h| h[str_ty] = Type.optional(str_ty) }
       scratch.add_constant(klass_obj, :ENV, env_ty, false)
+
+      scratch.search_method(Type::Builtin[:kernel], false, :sprintf) do |mdefs,|
+        mdefs.each do |mdef|
+          scratch.add_method(klass_vmcore, :"core#sprintf", false, mdef)
+        end
+      end
     end
   end
 end

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)
@@ -98,7 +99,7 @@ module TypeProf
       if rb.is_a?(Array) # [String name, String content]
         iseq = ISeq.compile_str(*rb.reverse)
       else
-        iseq = ISeq.compile(rb)
+        iseq = rb
       end
       scratch.add_entrypoint(iseq)
     end

data/lib/typeprof/container-type.rb

@@ -307,7 +307,11 @@ module TypeProf
         def screen_name(scratch)
           if @rest_ty == Type.bot
             if @lead_tys.empty?
-              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+              # This is heuristic: in general, an empty array is a wrong guess.
+              # Note that an empty array is representable as "[ ]" in RBS, but
+              # users often have to modify it to "Array[something]".
+              # In this term, "Array[untyped]" is considered more useful than "[ ]".
+              return "Array[untyped]"
             end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
@@ -673,6 +677,8 @@ module TypeProf
               k_ty = k_ty.union(k)
               v_ty = v_ty.union(v)
             end
+            k_ty = Type.any if k_ty == Type.bot
+            v_ty = Type.any if v_ty == Type.bot
             k_ty = k_ty.screen_name(scratch)
             v_ty = v_ty.screen_name(scratch)
             "Hash[#{ k_ty }, #{ v_ty }]"

data/lib/typeprof/export.rb

@@ -69,14 +69,17 @@ module TypeProf
     end
 
     def show_gvars(scratch, gvars, output)
+      gvars = gvars.dump.filter_map do |gvar_name, entry|
+        if entry.type != Type.bot && !entry.rbs_declared
+          [gvar_name, entry]
+        end
+      end
       # A signature for global variables is not supported in RBS
-      return if gvars.dump.empty?
+      return if gvars.empty?
 
       output.puts "# Global variables"
-      gvars.dump.each do |gvar_name, entry|
-        next if entry.type == Type.bot
-        s = entry.rbs_declared ? "#" : ""
-        output.puts s + "#{ gvar_name }: #{ entry.type.screen_name(scratch) }"
+      gvars.each do |gvar_name, entry|
+        output.puts "#{ gvar_name }: #{ entry.type.screen_name(scratch) }"
       end
       output.puts
     end
@@ -149,6 +152,7 @@ module TypeProf
             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

@@ -373,25 +373,30 @@ module TypeProf
     end
 
     def conv_block(rbs_block)
-      type = rbs_block.type
+      blk = rbs_block.type
 
-      # XXX
-      raise NotImplementedError unless type.optional_keywords.empty?
-      raise NotImplementedError unless type.required_keywords.empty?
-      raise NotImplementedError if type.rest_keywords
-
-      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)
@@ -454,6 +459,8 @@ module TypeProf
         end
       when RBS::Types::Union
         [:union, ty.types.map {|ty2| conv_type(ty2) }.compact]
+      when RBS::Types::Intersection
+        [:intersection, ty.types.map {|ty2| conv_type(ty2) }.compact]
       when RBS::Types::Optional
         [:optional, conv_type(ty.type)]
       when RBS::Types::Interface
@@ -630,7 +637,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)
 
@@ -643,13 +656,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
 
@@ -694,7 +730,10 @@ 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 :intersection
+        tys = ty[1]
+        conv_type(tys.first) # XXX: This is wrong! We need to support intersection type
       when :var
         Type::Var.new(ty[1])
       when :proc

data/lib/typeprof/iseq.rb

@@ -3,75 +3,65 @@ module TypeProf
     # 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)
-      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)
+    class << self
+      def compile(file)
+        compile_core(nil, file)
+      end
+
+      def compile_str(str, path = nil)
+        compile_core(str, path)
+      end
+
+      private def compile_core(str, path)
+        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
+
+        if str
+          iseq = RubyVM::InstructionSequence.compile(str, path, **opt)
+        else
+          iseq = RubyVM::InstructionSequence.compile_file(path, **opt)
+        end
+
+        return new(iseq.to_a)
+      end
     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)
+    Insn = Struct.new(:insn, :operands, :lineno)
+    class Insn
+      def check?(insn_cmp, operands_cmp = nil)
+        return insn == insn_cmp && (!operands_cmp || operands == operands_cmp)
+      end
     end
 
-    FRESH_ID = [0]
+    ISEQ_FRESH_ID = [0]
 
     def initialize(iseq)
-      @id = FRESH_ID[0]
-      FRESH_ID[0] += 1
+      @id = (ISEQ_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
 
-      case @type
-      when :method, :block
-        if @fargs_format[:opt]
-          label = @fargs_format[:opt].last
-          i = insns.index(label) + 1
-        else
-          i = insns.find_index {|insn| insn.is_a?(Array) }
-        end
-        # skip keyword initialization
-        while insns[i][0] == :checkkeyword
-          raise if insns[i + 1][0] != :branchif
-          label = insns[i + 1][1]
-          i = insns.index(label) + 1
-        end
-        insns[i, 0] = [[:_iseq_body_start]]
-      end
+      convert_insns(insns)
 
-      # rescue/ensure clauses need to have a dedicated return addresses
-      # because they requires to be virtually called.
-      # So, this preprocess adds "nop" to make a new insn for their return addresses
-      special_labels = {}
-      catch_table.map do |type, iseq, first, last, cont, stack_depth|
-        special_labels[cont] = true if type == :rescue || type == :ensure
-      end
+      add_body_start_marker(insns)
 
-      @insns = []
-      @linenos = []
+      add_exception_cont_marker(insns, catch_table)
 
-      labels = setup_iseq(insns, special_labels)
+      labels = create_label_table(insns)
 
-      # checkmatch->branch
-      # send->branch
+      @insns = setup_insns(insns, labels)
+
+      @fargs_format[:opt] = @fargs_format[:opt].map {|l| labels[l] } if @fargs_format[:opt]
 
       @catch_table = []
       catch_table.map do |type, iseq, first, last, cont, stack_depth|
         iseq = iseq ? ISeq.new(iseq) : nil
-        target = labels[special_labels[cont] ? :"#{ cont }_special" : cont]
+        target = labels[cont]
         entry = [type, iseq, target, stack_depth]
         labels[first].upto(labels[last]) do |i|
           @catch_table[i] ||= []
@@ -79,43 +69,143 @@ module TypeProf
         end
       end
 
-      merge_branches
+      rename_insn_types
+
+      unify_instructions
+    end
+
+    def source_location(pc)
+      "#{ @path }:#{ @insns[pc].lineno }"
+    end
 
-      analyze_stack
+    attr_reader :name, :path, :absolute_path, :start_lineno, :type, :locals, :fargs_format, :catch_table, :insns
+    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 <=>(other)
       @id <=> other.id
     end
 
-    def setup_iseq(insns, special_labels)
+    # Remove lineno entry and convert instructions to Insn instances
+    def convert_insns(insns)
+      ninsns = []
+      lineno = 0
+      insns.each do |e|
+        case e
+        when Integer # lineno
+          lineno = e
+        when Symbol # label or trace
+          ninsns << e
+        when Array
+          insn, *operands = e
+          ninsns << Insn.new(insn, operands, lineno)
+        else
+          raise "unknown iseq entry: #{ e }"
+        end
+      end
+      insns.replace(ninsns)
+    end
+
+    # Insert a dummy instruction "_iseq_body_start"
+    def add_body_start_marker(insns)
+      case @type
+      when :method, :block
+        # skip initialization code of optional arguments
+        if @fargs_format[:opt]
+          label = @fargs_format[:opt].last
+          i = insns.index(label) + 1
+        else
+          i = insns.find_index {|insn| insn.is_a?(Insn) }
+        end
+
+        # skip initialization code of keyword arguments
+        while insns[i][0] == :checkkeyword
+          raise if insns[i + 1].insn != :branchif
+          label = insns[i + 1].operands[0]
+          i = insns.index(label) + 1
+        end
+
+        insns.insert(i, Insn.new(:_iseq_body_start, [], @start_lineno))
+      end
+    end
+
+    # Insert "nop" instruction to continuation point of exception handlers
+    def add_exception_cont_marker(insns, catch_table)
+      # rescue/ensure clauses need to have a dedicated return addresses
+      # because they requires to be virtually called.
+      # So, this preprocess adds "nop" to make a new insn for their return addresses
+      exception_cont_labels = {}
+      catch_table.map! do |type, iseq, first, last, cont, stack_depth|
+        if type == :rescue || type == :ensure
+          exception_cont_labels[cont] = true
+          cont = :"#{ cont }_exception_cont"
+        end
+        [type, iseq, first, last, cont, stack_depth]
+      end
+
       i = 0
+      while i < insns.size
+        e = insns[i]
+        if exception_cont_labels[e]
+          insns.insert(i, :"#{ e }_exception_cont", Insn.new(:nop, []))
+          i += 2
+        end
+        i += 1
+      end
+    end
+
+    def create_label_table(insns)
+      pc = 0
       labels = {}
-      ninsns = []
       insns.each do |e|
-        if e.is_a?(Symbol) && e.to_s.start_with?("label")
-          if special_labels[e]
-            labels[:"#{ e }_special"] = i
-            ninsns << [:nop]
-            i += 1
-          end
-          labels[e] = i
+        if e.is_a?(Symbol)
+          labels[e] = pc
         else
-          i += 1 if e.is_a?(Array)
-          ninsns << e
+          pc += 1
         end
       end
+      labels
+    end
 
-      lineno = 0
-      ninsns.each do |e|
+    def setup_insns(insns, labels)
+      ninsns = []
+      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|
+        when Insn
+          operands = (INSN_TABLE[e.insn] || []).zip(e.operands).map do |type, operand|
             case type
             when "ISEQ"
               operand && ISeq.new(operand)
@@ -131,81 +221,64 @@ module TypeProf
             end
           end
 
-          @insns << [insn, operands]
-          @linenos << lineno
+          ninsns << Insn.new(e.insn, operands, e.lineno)
         else
           raise "unknown iseq entry: #{ e }"
         end
       end
-
-      @fargs_format[:opt] = @fargs_format[:opt].map {|l| labels[l] } if @fargs_format[:opt]
-
-      labels
+      ninsns
     end
 
-    def merge_branches
-      @insns.size.times do |i|
-        insn, operands = @insns[i]
-        case insn
+    def rename_insn_types
+      @insns.each do |insn|
+        case insn.insn
         when :branchif
-          @insns[i] = [:branch, [:if] + operands]
+          insn.insn, insn.operands = :branch, [:if] + insn.operands
         when :branchunless
-          @insns[i] = [:branch, [:unless] + operands]
+          insn.insn, insn.operands = :branch, [:unless] + insn.operands
         when :branchnil
-          @insns[i] = [:branch, [:nil] + operands]
+          insn.insn, insn.operands = :branch, [:nil] + insn.operands
+        when :getblockparam, :getblockparamproxy
+          insn.insn = :getlocal
         end
       end
     end
 
-    def source_location(pc)
-      "#{ @path }:#{ @linenos[pc] }"
-    end
-
-    attr_reader :name, :path, :absolute_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
+    # Unify some instructions for flow-sensitive analysis
+    def unify_instructions
+      # This method rewrites instructions to enable flow-sensitive analysis.
+      #
+      # Consider `if x; ...; else; ... end`.
+      # When the variable `x` is of type "Integer | nil",
+      # we want to make sure that `x` is "Integer" in then clause.
+      # So, we need to split the environment to two ones:
+      # one is that `x` is of type "Integer", and the other is that
+      # `x` is type "nil".
+      #
+      # However, `if x` is compiled to "getlocal; branch".
+      # TypeProf evaluates them as follows:
+      #
+      # * "getlocal" pushes the value of `x` to the stack, amd
+      # * "branch" checks the value on the top of the stack
+      #
+      # TypeProf does not keep where the value comes from, so
+      # it is difficult to split the environment when evaluating "branch".
+      #
+      # This method rewrites "getlocal; branch" to "nop; getlocal_branch".
+      # The two instructions are unified to "getlocal_branch" instruction,
+      # so TypeProf can split the environment.
+      #
+      # This is a very fragile appoach because it highly depends on the compiler of Ruby.
 
-    def analyze_stack
       # gather branch targets
       # TODO: catch_table should be also considered
       branch_targets = {}
-      @insns.each do |insn, operands|
-        case insn
+      @insns.each do |insn|
+        case insn.insn
         when :branch
-          branch_targets[operands[1]] = true
+          branch_targets[insn.operands[1]] = true
         when :jump
-          branch_targets[operands[0]] = true
+          branch_targets[insn.operands[0]] = true
         end
       end
 
@@ -215,25 +288,27 @@ module TypeProf
       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
+          insn = @insns[i]
+          next unless insn.insn == :getlocal && insn.operands[1] == 0
+          getlocal_operands = insn.operands
           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, []]
+            case @insns[j].insn
+            when :dup
+              break unless @insns[j + 1].check?(:putnil, [])
+              break unless @insns[j + 2].check?(:putobject, [true])
+              break unless @insns[j + 3].check?(:getconstant) # TODO: support A::B::C
+              break unless @insns[j + 4].check?(:checkmatch, [2])
+              break unless @insns[j + 5].check?(:branch)
+              target_pc = @insns[j + 5].operands[1]
+              break unless @insns[target_pc].check?(:pop, [])
               nops << j << (j + 4) << target_pc
-              new_insns << [j + 5, [:getlocal_checkmatch_branch, [getlocal_operands, @insns[j + 5][1]]]]
+              branch_operands = @insns[j + 5][1]
+              new_insns << [j + 5, Insn.new(:getlocal_checkmatch_branch, [getlocal_operands, branch_operands])]
               j += 6
-            when [:pop, []]
+            when :pop
               nops << j
               case_branch_list << [nops, new_insns]
               break
@@ -244,25 +319,28 @@ module TypeProf
         end
       else
         (@insns.size - 1).times do |i|
-          insn0, getlocal_operands = @insns[i]
-          next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
+          insn = @insns[i]
+          next unless insn.insn == :getlocal && insn.operands[1] == 0
+          getlocal_operands = insn.operands
           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, []]
+            insn = @insns[j]
+            if insn.check?(:putnil, [])
+              break unless @insns[j + 1].check?(:putobject, [true])
+              break unless @insns[j + 2].check?(:getconstant) # TODO: support A::B::C
+              break unless @insns[j + 3].check?(:topn, [1])
+              break unless @insns[j + 4].check?(:send, [{:mid=>:===, :flag=>20, :orig_argc=>1}, nil])
+              break unless @insns[j + 5].check?(:branch)
+              target_pc = @insns[j + 5].operands[1]
+              break unless @insns[target_pc].check?(:pop, [])
               nops << (j + 4) #<< target_pc
-              new_insns << [j + 5, [:arg_getlocal_send_branch, [getlocal_operands, @insns[j + 4][1], @insns[j + 5][1]]]]
+              send_operands = @insns[j + 4][1]
+              branch_operands = @insns[j + 5][1]
+              new_insns << [j + 5, Insn.new(:arg_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands])]
               j += 6
-            when [:pop, []]
+            elsif insn.check?(:pop, [])
               #nops << j
               case_branch_list << [nops, new_insns]
               break
@@ -273,15 +351,15 @@ module TypeProf
         end
       end
       case_branch_list.each do |nops, new_insns|
-        nops.each {|i| @insns[i] = [:nop, []] }
+        nops.each {|i| @insns[i] = Insn.new(: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
+        insn = @insns[i]
+        if insn.insn == :getlocal && insn.operands[1] == 0
           j = i + 1
           sp = 1
           while @insns[j]
@@ -297,94 +375,118 @@ module TypeProf
       end
       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] = [:recv_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
+        getlocal_operands = @insns[i].operands
+        send_operands = @insns[j].operands
+        branch_operands = @insns[j + 1].operands
+        @insns[j] = Insn.new(:nop, [])
+        @insns[j + 1] = Insn.new(: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
+        insn1 = @insns[i]
+        next unless insn1.insn == :getlocal && insn1.operands[1] == 0
+        insn2 = @insns[i + 1]
+        next unless insn2.insn == :send
+        send_operands = insn2.operands[0]
+        next unless send_operands[:flag] == 16 && send_operands[:orig_argc] == 1
+        insn3 = @insns[i + 2]
+        next unless insn3.insn == :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]]
+        getlocal_operands = @insns[i].operands
+        send_operands = @insns[i + 1].operands
+        branch_operands = @insns[i + 2].operands
+        @insns[i + 1] = Insn.new(:nop, [])
+        @insns[i + 2] = Insn.new(:arg_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands])
       end
 
       # find a pattern: send (block_given?), branch
       send_branch_list = []
       (@insns.size - 1).times do |i|
-        insn, _operands = @insns[i]
-        if insn == :send
-          insn, _operands = @insns[i + 1]
-          if insn == :branch
+        insn = @insns[i]
+        if insn.insn == :send
+          insn = @insns[i + 1]
+          if insn.insn == :branch
             send_branch_list << i
           end
         end
       end
       send_branch_list.each do |i|
         next if branch_targets[i + 1]
-        _insn, send_operands = @insns[i]
-        _insn, branch_operands = @insns[i + 1]
-        @insns[i] = [:nop]
-        @insns[i + 1] = [:send_branch, [send_operands, branch_operands]]
+        send_operands = @insns[i].operands
+        branch_operands = @insns[i + 1].operands
+        @insns[i] = Insn.new(:nop, [])
+        @insns[i + 1] = Insn.new(:send_branch, [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]]
+        insn0 = @insns[i]
+        insn1 = @insns[i + 1]
+        insn2 = @insns[i + 2]
+        if insn0.insn == :getlocal && insn1.insn == :dup && insn2.insn == :branch && insn0.operands[1] == 0
+          getlocal_operands = insn0.operands
+          dup_operands      = insn1.operands
+          branch_operands   = insn2.operands
+          @insns[i    ] = Insn.new(:nop, [])
+          @insns[i + 1] = Insn.new(:nop, [])
+          @insns[i + 2] = Insn.new(:getlocal_dup_branch, [getlocal_operands, dup_operands, branch_operands])
+        end
+      end
+
+      # find a pattern: dup, setlocal, branch
+      (@insns.size - 2).times do |i|
+        next if branch_targets[i + 1] || branch_targets[i + 2]
+        insn0 = @insns[i]
+        insn1 = @insns[i + 1]
+        insn2 = @insns[i + 2]
+        if insn0.insn == :dup && insn1.insn == :setlocal && insn2.insn == :branch && insn1.operands[1] == 0
+          dup_operands      = insn0.operands
+          setlocal_operands = insn1.operands
+          branch_operands   = insn2.operands
+          @insns[i    ] = Insn.new(:nop, [])
+          @insns[i + 1] = Insn.new(:nop, [])
+          @insns[i + 2] = Insn.new(:dup_setlocal_branch, [dup_operands, setlocal_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]]
+        insn0 = @insns[i]
+        insn1 = @insns[i + 1]
+        if insn0.insn == :dup && insn1.insn == :branch
+          dup_operands    = insn0.operands
+          branch_operands = insn1.operands
+          @insns[i    ] = Insn.new(:nop, [])
+          @insns[i + 1] = Insn.new(: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]
-        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]]
+        insn0 = @insns[i]
+        insn1 = @insns[i + 1]
+        if insn0.insn == :getlocal && insn0.operands[1] == 0 && insn1.insn == :branch
+          getlocal_operands = insn0.operands
+          branch_operands   = insn1.operands
+          @insns[i    ] = Insn.new(:nop, [])
+          @insns[i + 1] = Insn.new(:getlocal_branch, [getlocal_operands, branch_operands])
         end
       end
     end
 
     def check_send_branch(sp, j)
-      insn, operands = @insns[j]
+      insn = @insns[j]
+      operands = insn.operands
 
-      case insn
+      case insn.insn
       when :putspecialobject, :putnil, :putobject, :duparray, :putstring,
            :putself
         sp += 1
@@ -422,7 +524,7 @@ module TypeProf
         argc += 1 # receiver
         argc += kw_arg.size if kw_arg
         sp -= argc
-        return :match if insn == :send && sp == 0 && @insns[j + 1][0] == :branch
+        return :match if insn.insn == :send && sp == 0 && @insns[j + 1].insn == :branch
         sp += 1
       when :arg_getlocal_send_branch
         return # not implemented