typeprof 0.10.0 → 0.14.1

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]

data/lib/typeprof/type.rb

@@ -162,6 +162,10 @@ module TypeProf
       substitute(DummySubstitution, Config.options[:type_depth_limit])
     end
 
+    def include_untyped?(_scratch)
+      false
+    end
+
     class Any < Type
       def initialize
       end
@@ -185,6 +189,10 @@ module TypeProf
       def substitute(_subst, _depth)
         self
       end
+
+      def include_untyped?(_scratch)
+        true
+      end
     end
 
     class Void < Any
@@ -379,6 +387,17 @@ module TypeProf
         end
         ty
       end
+
+      def include_untyped?(scratch)
+        @types.each do |ty|
+          return true if ty.include_untyped?(scratch)
+        end
+        @elems&.each do |(container_kind, base_type), elems|
+          return true if base_type.include_untyped?(scratch)
+          return true if elems.include_untyped?(scratch)
+        end
+        false
+      end
     end
 
     def self.any
@@ -583,6 +602,10 @@ module TypeProf
       def screen_name(scratch)
         scratch.show_proc_signature([self])
       end
+
+      def include_untyped?(scratch)
+        false # XXX: need to check the block signatures recursively
+      end
     end
 
     class Symbol < Type
@@ -869,6 +892,17 @@ module TypeProf
       @blk_ty = blk_ty
     end
 
+    def include_untyped?(scratch)
+      return true if @lead_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @opt_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @rest_ty&.include_untyped?(scratch)
+      return true if @post_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @kw_tys&.any? {|_, _, ty| ty.include_untyped?(scratch) }
+      return true if @kw_rest_ty&.include_untyped?(scratch)
+      return true if @blk_ty&.include_untyped?(scratch)
+      false
+    end
+
     attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
 
     def substitute(subst, depth)

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.10.0"
+  VERSION = "0.14.1"
 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/class_eval.rb

@@ -0,0 +1,22 @@
+module Foo
+end
+
+module Bar
+  Foo.class_eval do
+    @foo = self
+    def foo
+      "str"
+    end
+  end
+end
+
+__END__
+# Classes
+module Foo
+  self.@foo: singleton(Foo)
+
+  def self.foo: -> String
+end
+
+module Bar
+end

data/smoke/define_method7.rb

@@ -0,0 +1,18 @@
+class Human
+  define_method(:fo) { }
+  
+  [:a, :b].each { |m|
+    define_method(m) { }
+  }
+end
+
+Human.new.a
+Human.new.b
+
+__END__
+# Classes
+class Human
+  def fo: -> nil
+  def a: -> nil
+  def b: -> nil
+end

data/smoke/extended.rb

@@ -0,0 +1,38 @@
+module Foo
+  @extended = []
+  def self.extended(klass)
+    @extended << klass
+  end
+end
+
+class C
+  extend Foo
+end
+
+class D
+  extend Foo
+end
+
+class E
+  extend Foo
+end
+
+__END__
+# Classes
+module Foo
+  self.@extended: Array[singleton(C) | singleton(D) | singleton(E)]
+
+  def self.extended: (singleton(C) | singleton(D) | singleton(E) klass) -> (Array[singleton(C) | singleton(D) | singleton(E)])
+end
+
+class C
+  extend Foo
+end
+
+class D
+  extend Foo
+end
+
+class E
+  extend Foo
+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

data/smoke/included.rb

@@ -0,0 +1,38 @@
+module Foo
+  @included = []
+  def self.included(klass)
+    @included << klass
+  end
+end
+
+class C
+  include Foo
+end
+
+class D
+  include Foo
+end
+
+class E
+  include Foo
+end
+
+__END__
+# Classes
+module Foo
+  self.@included: Array[singleton(C) | singleton(D) | singleton(E)]
+
+  def self.included: (singleton(C) | singleton(D) | singleton(E) klass) -> (Array[singleton(C) | singleton(D) | singleton(E)])
+end
+
+class C
+  include Foo
+end
+
+class D
+  include Foo
+end
+
+class E
+  include Foo
+end

data/smoke/inherited.rb

@@ -0,0 +1,26 @@
+class Foo
+  @inherited = []
+  def self.inherited(klass)
+    @inherited << klass
+  end
+end
+
+class Bar < Foo
+end
+
+class Baz < Foo
+end
+
+__END__
+# Classes
+class Foo
+  self.@inherited: Array[singleton(Bar) | singleton(Baz)]
+
+  def self.inherited: (singleton(Bar) | singleton(Baz) klass) -> (Array[singleton(Bar) | singleton(Baz)])
+end
+
+class Bar < Foo
+end
+
+class Baz < Foo
+end

data/smoke/instance_eval.rb

@@ -13,6 +13,6 @@ end
 __END__
 # Classes
 class C
-  def self.foo: { (C) -> nil } -> C
+  def self.foo: { (C) -> nil } -> nil
   def log: (Integer n) -> nil
 end