typeprof 0.15.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcefd3a4da176820246ad53757286aa1f7f8b2d21a6d1300763c91ba252e95ca
-  data.tar.gz: 1bf7429a4cf7d59e1ab4ca10f5f065a22b85adbbda922c67060d0ede64aab60f
+  metadata.gz: 52c9e6c0c338fb19da0264929bce36b903cdedf7be3b6a031deef525e28be8d4
+  data.tar.gz: 8c17fe8549a7c44c8a11a1db9a40384b05f4025e5ec23140fee09eaf349d855c
 SHA512:
-  metadata.gz: ff14f14aa923ca807db9d7f1bc7f537c46e735bd194a0b59758dfdba0e04c04175ca0505fe6c00f739fec7933eeeab5010646891f56e14d5245f5b8613dd7d3b
-  data.tar.gz: 73a05bece353a7b4dbefba9f16e723fb088795e9f029b143721b03543e53ae19a8adb9908b3de41c839fbfb10a8d34c76ed0fa4f1b072801d7334233be63b1c9
+  metadata.gz: 74d8eddbd6010287d33c9891a59112f7f9edf1aa2f3ea24d07142e1d81e1c03508b1362a3630f092138352616a8258e973784d926293882894ba933123851f88
+  data.tar.gz: 77bc3c7f268b11663f561829c4b1a2c4917e137c0e56c3b4e734f29862c011e7095b2d1939a352534f78003159d90f07f8de81ce1304819f4f79e5d5ac6f7242

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.15.0)
+    typeprof (0.15.1)
       rbs (>= 1.3.1)
 
 GEM
@@ -11,7 +11,7 @@ GEM
     docile (1.4.0)
     power_assert (2.0.0)
     rake (13.0.1)
-    rbs (1.3.1)
+    rbs (1.3.3)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

data/lib/typeprof/analyzer.rb

@@ -286,6 +286,7 @@ module TypeProf
       @anonymous_struct_gen_id = 0
 
       @types_being_shown = []
+      @namespace = nil
     end
 
     def add_entrypoint(iseq)
@@ -1118,15 +1119,16 @@ module TypeProf
       env = @ep2env[ep]
       raise "nil env" unless env
 
-      insn, operands = ep.ctx.iseq.insns[ep.pc]
+      insn = ep.ctx.iseq.insns[ep.pc]
+      operands = insn.operands
 
       if Config.verbose >= 2
         # XXX: more dedicated output
         puts "DEBUG: stack=%p" % [env.stack]
-        puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn, env.stack.size]
+        puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn.insn, env.stack.size]
       end
 
-      case insn
+      case insn.insn
       when :_iseq_body_start
         # XXX: reconstruct and record the method signature
         iseq = ep.ctx.iseq
@@ -1641,7 +1643,7 @@ module TypeProf
           return
         end
 
-      when :getlocal, :getblockparam, :getblockparamproxy
+      when :getlocal
         var_idx, scope_idx, _escaped = operands
         if scope_idx == 0
           ty = env.get_local(-var_idx+2)
@@ -1682,18 +1684,12 @@ module TypeProf
         getlocal_operands, _dup_operands, branch_operands = operands
         var_idx, _scope_idx, _escaped = getlocal_operands
         ret_ty = env.get_local(-var_idx+2)
-        unless ret_ty
-          p env.locals
-          raise
-        end
 
         branchtype, target, = branch_operands
         # branchtype: :if or :unless or :nil
         ep_then = ep.next
         ep_else = ep.jump(target)
 
-        var_idx, _scope_idx, _escaped = getlocal_operands
-
         ret_ty.each_child do |ret_ty|
           flow_env = env.local_update(-var_idx+2, ret_ty).push(ret_ty)
           case ret_ty
@@ -1707,6 +1703,31 @@ module TypeProf
           end
         end
         return
+      when :dup_setlocal_branch
+        _dup_operands, setlocal_operands, branch_operands = operands
+
+        env, (ret_ty,) = env.pop(1)
+
+        var_idx, _scope_idx, _escaped = setlocal_operands
+
+        branchtype, target, = branch_operands
+        # branchtype: :if or :unless or :nil
+        ep_then = ep.next
+        ep_else = ep.jump(target)
+
+        ret_ty.each_child do |ret_ty|
+          flow_env = env.local_update(-var_idx+2, ret_ty)
+          case ret_ty
+          when Type.any
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
+          when Type::Instance.new(Type::Builtin[:false]), Type.nil
+            merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+          else
+            merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+          end
+        end
+        return
       when :getlocal_checkmatch_branch
         getlocal_operands, branch_operands = operands
         var_idx, _scope_idx, _escaped = getlocal_operands
@@ -1970,7 +1991,7 @@ module TypeProf
         end
         env = env.push(ty)
       else
-        raise "Unknown insn: #{ insn }"
+        raise "Unknown insn: #{ insn.insn }"
       end
 
       add_edge(ep, ep)
@@ -2204,7 +2225,7 @@ module TypeProf
         if blk.is_a?(Type::Proc)
           blk.block_body.do_call(aargs, ep, env, self, replace_recv_ty: replace_recv_ty, replace_cref: replace_cref, &ctn)
         else
-          warn(ep, "non-proc is passed as a block")
+          warn(ep, "non-proc is passed as a block") if blk != Type.any
           ctn[Type.any, ep, env]
         end
       end

data/lib/typeprof/builtin.rb

@@ -813,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]
@@ -825,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)
@@ -880,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/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

data/lib/typeprof/method.rb

@@ -283,12 +283,12 @@ module TypeProf
             # 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]
+            ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
           end
         else
           ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
           ret_ty = ret_ty.remove_type_vars
-          ctn[ret_ty, caller_ep, ncaller_env]
+          ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
         end
       end
 

data/lib/typeprof/type.rb

@@ -895,7 +895,7 @@ module TypeProf
         fargs << ("**" + all_val_ty.screen_name(scratch))
       end
       if Config.options[:show_parameter_names]
-        farg_names = farg_names.map {|name| name == :type ? :type_ : name } # XXX: workaround of RBS parser bug
+        farg_names = farg_names.map {|name| RBS::Parser::KEYWORDS.key?(name.to_s) ? "`#{name}`" : name }
         farg_names = farg_names.map {|name| name.is_a?(Integer) ? "noname_#{ name }" : name }
         fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
       end

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.15.0"
+  VERSION = "0.15.1"
 end

data/smoke/break2.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> (Integer | String)
+  def foo: -> String
 end

data/smoke/identifier_keywords.rb

@@ -0,0 +1,17 @@
+def type(type)
+end
+
+def out(*out)
+end
+
+def untyped(untyped:)
+end
+
+__END__
+# Classes
+class Object
+  private
+  def type: (untyped `type`) -> nil
+  def out: (*untyped `out`) -> nil
+  def untyped: (untyped: untyped) -> nil
+end

data/smoke/next2.rb

@@ -13,5 +13,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: { -> (Integer | String) } -> (Integer | String)
+  def foo: { -> Integer } -> Integer
 end

data/smoke/or_raise.rb

@@ -0,0 +1,18 @@
+def foo
+  if rand < 0.5
+    1
+  end
+end
+
+def bar
+  x = foo or raise("nil")
+  x.times { }
+end
+
+__END__
+# Classes
+class Object
+  private
+  def foo: -> Integer?
+  def bar: -> Integer
+end

data/smoke/pattern-match1.rb

@@ -1,4 +1,5 @@
 # RUBY_VERSION >= 3.0
+# NO_SHOW_ERRORS
 
 def foo
   case [:a, :b, :c]
@@ -11,12 +12,6 @@ end
 foo
 
 __END__
-# Errors
-smoke/pattern-match1.rb:5: [error] undefined method: nil#length
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-
 # Classes
 class Object
   private

data/testbed/ao.rb

@@ -291,7 +291,7 @@ end
 
 top
 
-if _dummy = false
+if $0 == __FILE__
   v = Vec.new(0.0, 0.0, 0.0)
   v.vadd(v)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-21 00:00:00.000000000 Z
+date: 2021-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -217,6 +217,7 @@ files:
 - smoke/hash4.rb
 - smoke/hash5.rb
 - smoke/huge_union.rb
+- smoke/identifier_keywords.rb
 - smoke/included.rb
 - smoke/inheritance.rb
 - smoke/inheritance2.rb
@@ -276,6 +277,7 @@ files:
 - smoke/optional1.rb
 - smoke/optional2.rb
 - smoke/optional3.rb
+- smoke/or_raise.rb
 - smoke/parameterizedd-self.rb
 - smoke/parameterizedd-self2.rb
 - smoke/pathname1.rb