typeprof 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 501623610b473ab2fdd870686387a26ae787b8e3af6254a7a443967acb0b9f17
-  data.tar.gz: 0ace065239fb606719b1a716c7ce38e312c3b1b07f238d3f1a67e66eaf261567
+  metadata.gz: c03cc70d70c73d14871e07c098b0689e11afc8e309662a8d4402c6f2ecbc5d02
+  data.tar.gz: '097a04710ef19e6c8f29304c901dd8569e9e74a436dd1d76a5bf515df7fdfa41'
 SHA512:
-  metadata.gz: b5b437508d0b83d3966a07266cebef3aa64e98ef4b33e75cd9deb5a615019fdb054f00ffb433d2af573258192bfd7346845dc870db32540b928314999c8e818c
-  data.tar.gz: 2aaa6b88e7d41676d989b3ac01057af13cf7247569e68b9be57b919e210afa140d016e3d27522fa8f03362fa17a3fb46356d3be1bd770a251c825cb4477334e6
+  metadata.gz: f5348942872848edec6b679db2a9afa60b746a6d3908f7066dfcd3a551d04ab728ea1494a5bdcf66867d7bc47ba0dce6ce29e2d29833babb5413262c8da92ca1
+  data.tar.gz: 9b214f8a4a24fa433a9c3d7fb205246b161c723206a73db257eb57b3905b34ab7ef378324a7786b63daccdf763616667c2d5d6fcbaf98ff6ff455f26f956082e

data/lib/typeprof/analyzer.rb

@@ -1324,7 +1324,7 @@ module TypeProf
           end
         end
         return
-      when :getlocal_send_branch
+      when :recv_getlocal_send_branch
         getlocal_operands, send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
@@ -1352,6 +1352,39 @@ module TypeProf
           end
         end
         return
+      when :arg_getlocal_send_branch
+        getlocal_operands, send_operands, branch_operands = operands
+        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
+        raise if aargs.lead_tys.size != 1
+        aarg = aargs.lead_tys[0]
+        aarg = Type.any if aarg == Type.bot
+        recvs.each_child do |recv|
+          aarg.each_child do |aarg|
+            aargs_tmp = ActualArguments.new([aarg], nil, {}, aargs.blk_ty)
+            do_send(recv, mid, aargs_tmp, ep, env) do |ret_ty, ep, env|
+              env, ret_ty, = localize_type(ret_ty, env, ep)
+
+              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
+              flow_env = env.local_update(-var_idx+2, aarg)
+
+              case ret_ty
+              when Type::Instance.new(Type::Builtin[:true])
+                merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+              when Type::Instance.new(Type::Builtin[:false])
+                merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+              else
+                merge_env(ep_then, env)
+                merge_env(ep_else, env)
+              end
+            end
+          end
+        end
+        return
       when :send_branch
         send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
@@ -1455,7 +1488,7 @@ module TypeProf
             end
             _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc]&.find {|type,| type == :break }
             if cont
-              nenv = @return_envs[tmp_ep]
+              nenv = @return_envs[tmp_ep] || env
               nenv, = nenv.pop(nenv.stack.size - stack_depth)
               nenv = nenv.push(ty)
               tmp_ep = tmp_ep.jump(cont)
@@ -1814,8 +1847,10 @@ module TypeProf
       when :nop
       when :setn
         idx, = operands
-        env, (ty,) = env.pop(1)
-        env = env.setn(idx, ty).push(ty)
+        if idx >= 1
+          env, (ty,) = env.pop(1)
+          env = env.setn(idx, ty).push(ty)
+        end
       when :topn
         idx, = operands
         env = env.topn(idx)

data/lib/typeprof/builtin.rb

@@ -163,6 +163,27 @@ module TypeProf
       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")
@@ -829,6 +850,7 @@ module TypeProf
       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/iseq.rb

@@ -206,8 +206,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 (RUBY_VERSION.split(".") <=> %w(3 1 0)) < 0
+        (@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 +284,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 +292,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 +376,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 +421,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]

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/smoke/break4.rb

@@ -0,0 +1,17 @@
+# The following "break" is compiled as "throw" instruction since https://github.com/ruby/ruby/commit/34bc8210ed1624dc6ba24afef4616baa5a934df9
+def foo
+  begin
+    while true
+      break 1
+    end
+  rescue
+    "foo"
+  end
+end
+
+__END__
+# Classes
+class Object
+  private
+  def foo: -> (Integer | String)
+end

data/smoke/flow11.rb

@@ -0,0 +1,17 @@
+def foo(arg)
+  if Integer === arg
+    arg
+  else
+    42
+  end
+end
+
+foo("str")
+foo(1)
+
+__END__
+# Classes
+class Object
+  private
+  def foo: (Integer | String arg) -> Integer
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -138,6 +138,7 @@ files:
 - smoke/break1.rb
 - smoke/break2.rb
 - smoke/break3.rb
+- smoke/break4.rb
 - smoke/case.rb
 - smoke/case2.rb
 - smoke/case3.rb
@@ -192,6 +193,7 @@ files:
 - smoke/flip-flop.rb
 - smoke/flow1.rb
 - smoke/flow10.rb
+- smoke/flow11.rb
 - smoke/flow2.rb
 - smoke/flow3.rb
 - smoke/flow4.rb
@@ -409,7 +411,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.0.dev
 signing_key: 
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation