typeprof 0.9.0 → 0.12.0

data/lib/typeprof/iseq.rb

@@ -207,7 +207,7 @@ module TypeProf
       end
 
       # find a pattern: getlocal, ..., send (is_a?, respond_to?), branch
-      send_branch_list = []
+      getlocal_send_branch_list = []
       (@insns.size - 1).times do |i|
         insn, operands = @insns[i]
         if insn == :getlocal && operands[1] == 0
@@ -216,7 +216,7 @@ module TypeProf
           while @insns[j]
             sp = check_send_branch(sp, j)
             if sp == :match
-              send_branch_list << [i, j]
+              getlocal_send_branch_list << [i, j]
               break
             end
             break if !sp
@@ -224,13 +224,32 @@ module TypeProf
           end
         end
       end
-      send_branch_list.each do |i, j|
+      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] = [:send_branch, [getlocal_operands, send_operands, branch_operands]]
+        @insns[j + 1] = [: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
+            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]]
       end
 
       # find a pattern: getlocal, dup, branch

data/lib/typeprof/method.rb

@@ -1,5 +1,7 @@
 module TypeProf
   class MethodDef
+    attr_accessor :pub_meth
+
     include Utils::StructuralEquality
   end
 
@@ -12,8 +14,6 @@ module TypeProf
       @pub_meth = pub_meth
     end
 
-    attr_accessor :pub_meth
-
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
@@ -153,14 +153,34 @@ module TypeProf
     end
   end
 
+  class AliasMethodDef < MethodDef
+    def initialize(orig_mid, mdef, def_ep)
+      @orig_mid = orig_mid
+      @mdef = mdef
+      @pub_meth = mdef.pub_meth
+      @def_ep = def_ep
+    end
+
+    attr_reader :orig_mid, :mdef, :def_ep
+
+    def do_send(recv, _mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      @mdef.do_send(recv, @orig_mid, aargs, caller_ep, caller_env, scratch, &ctn)
+    end
+
+    def do_check_send(msig, recv, mid, ep, scratch)
+      @mdef.do_check_send(msig, recv, mid, ep, scratch)
+    end
+  end
+
   class AttrMethodDef < MethodDef
-    def initialize(ivar, kind, absolute_path)
+    def initialize(ivar, kind, pub_meth, def_ep)
       @ivar = ivar
       @kind = kind # :reader | :writer
-      @absolute_path = absolute_path
+      @pub_meth = pub_meth
+      @def_ep = def_ep
     end
 
-    attr_reader :ivar, :kind, :absolute_path
+    attr_reader :ivar, :kind, :def_ep
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       case @kind
@@ -185,9 +205,10 @@ module TypeProf
   end
 
   class TypedMethodDef < MethodDef
-    def initialize(sig_rets, rbs_source) # sig_rets: Array<[MethodSignature, (return)Type]>
+    def initialize(sig_rets, rbs_source, pub_meth) # sig_rets: Array<[MethodSignature, (return)Type]>
       @sig_rets = sig_rets
       @rbs_source = rbs_source
+      @pub_meth = pub_meth
     end
 
     attr_reader :rbs_source
@@ -286,8 +307,9 @@ module TypeProf
   end
 
   class CustomMethodDef < MethodDef
-    def initialize(impl)
+    def initialize(impl, pub_meth)
       @impl = impl
+      @pub_meth = pub_meth
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)

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
@@ -781,31 +804,56 @@ module TypeProf
   class Signature
     include Utils::StructuralEquality
 
-    def screen_name(scratch)
-      str = @lead_tys.map {|ty| ty.screen_name(scratch) }
+    def screen_name(iseq, scratch)
+      fargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
+      farg_names = []
+      farg_names += iseq.locals[0, @lead_tys.size] if iseq
       if @opt_tys
-        str += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        fargs += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        farg_names += iseq.locals[@lead_tys.size, @opt_tys.size] if iseq
       end
       if @rest_ty
-        str << ("*" + @rest_ty.screen_name(scratch))
+        fargs << ("*" + @rest_ty.screen_name(scratch))
+        if iseq
+          rest_index = iseq.fargs_format[:rest_start]
+          farg_names << (rest_index ? iseq.locals[rest_index] : nil)
+        end
       end
       if @post_tys
-        str += @post_tys.map {|ty| ty.screen_name(scratch) }
+        fargs += @post_tys.map {|ty| ty.screen_name(scratch) }
+        if iseq
+          post_start = iseq.fargs_format[:post_start]
+          farg_names += (post_start ? iseq.locals[post_start, @post_tys.size] : [nil] * @post_tys.size)
+        end
       end
       if @kw_tys
         @kw_tys.each do |req, sym, ty|
           opt = req ? "" : "?"
-          str << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
+          fargs << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
         end
       end
       if @kw_rest_ty
-        str << ("**" + @kw_rest_ty.screen_name(scratch))
+        all_val_ty = Type.bot
+        @kw_rest_ty.each_child_global do |ty|
+          if ty == Type.any
+            val_ty = ty
+          else
+            # ty is a Type::Hash
+            _key_ty, val_ty = ty.elems.squash
+          end
+          all_val_ty = all_val_ty.union(val_ty)
+        end
+        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
+        fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
       end
-      str = str.empty? ? "" : "(#{ str.join(", ") })"
+      fargs = fargs.empty? ? "" : "(#{ fargs.join(", ") })"
 
       # Dirty Hack: Stop the iteration at most once!
       # I'll remove this hack if RBS removes the limitation of nesting blocks
-      return str if caller_locations.any? {|frame| frame.label == "show_block_signature" }
+      return fargs if caller_locations.any? {|frame| frame.label == "show_block_signature" }
 
       optional = false
       blks = []
@@ -818,12 +866,12 @@ module TypeProf
         end
       end
       if blks != []
-        str << " " if str != ""
-        str << "?" if optional
-        str << scratch.show_block_signature(blks)
+        fargs << " " if fargs != ""
+        fargs << "?" if optional
+        fargs << scratch.show_block_signature(blks)
       end
 
-      str
+      fargs
     end
   end
 
@@ -838,9 +886,23 @@ module TypeProf
       @kw_tys = kw_tys
       kw_tys.each {|a| raise if a.size != 3 } if kw_tys
       @kw_rest_ty = kw_rest_ty
+      kw_rest_ty&.each_child_global do |ty|
+        raise ty.inspect if ty != Type.any && !ty.is_a?(Type::Hash)
+      end
       @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.9.0"
+  VERSION = "0.12.0"
 end

data/smoke/alias.rb

@@ -21,11 +21,11 @@ __END__
 # Classes
 class Object
   private
-  def foo: (Integer) -> Integer
-  def bar: (String) -> String
+  def foo: (Integer | String x) -> (Integer | String)
+  alias bar foo
 end
 
 class Test
-  def baz: (Integer) -> Integer
-  def qux: (String) -> String
+  def baz: (Integer | String x) -> (Integer | String)
+  alias qux baz
 end

data/smoke/alias2.rb

@@ -15,5 +15,7 @@ class Foo
   @a: :x
   @b: :y
   @c: :z
-  def initialize: (:x, :y, :z) -> [:x, :y, :z]
+
+  alias self.[] self.new
+  def initialize: (:x a, :y b, :z c) -> [:x, :y, :z]
 end

data/smoke/arguments.rb

@@ -12,6 +12,6 @@ smoke/arguments.rb:6: [error] wrong number of arguments (given 2, expected 1)
 # Classes
 class Object
   private
-  def foo: (untyped) -> nil
-  def bar: (untyped) -> nil
+  def foo: (untyped x) -> nil
+  def bar: (untyped x) -> nil
 end

data/smoke/arguments2.rb

@@ -44,13 +44,13 @@ __END__
 class Object
   private
   def f1: -> nil
-  def f2: (:x, :y, :z) -> nil
-  def f3: (?String, ?String) -> nil
-  def f4: (*:a | :b | :c) -> nil
-  def f5: (:x, ?String, :z) -> nil
+  def f2: (:x x, :y y, :z z) -> nil
+  def f3: (?String x, ?String y) -> nil
+  def f4: (*:a | :b | :c r) -> nil
+  def f5: (:x x, ?String y, :z z) -> nil
   def f6: (k: :kk) -> nil
   def f7: (?k: Integer) -> nil
   def f8: (?k: String) -> nil
-  def f9: (**{k: :kk}) -> nil
+  def f9: (**:kk) -> nil
   def f10: { (Integer) -> nil } -> nil
 end

data/smoke/array-each.rb

@@ -11,5 +11,5 @@ __END__
 # Classes
 class Object
   private
-  def log: ((:sym | Integer | String)?) -> nil
+  def log: ((:sym | Integer | String)? x) -> nil
 end

data/smoke/array-each3.rb

@@ -9,5 +9,5 @@ __END__
 # Classes
 class Object
   private
-  def log: (bot) -> nil
+  def log: (bot x) -> nil
 end

data/smoke/array-map.rb

@@ -8,5 +8,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: ([Integer, Integer, Integer]) -> Array[String]
+  def foo: ([Integer, Integer, Integer] a) -> Array[String]
 end

data/smoke/array-map2.rb

@@ -7,5 +7,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  def foo: ([Integer, Integer, Integer] a) -> (Array[Integer | String])
 end

data/smoke/array-map3.rb

@@ -17,7 +17,7 @@ __END__
 # Classes
 class Object
   private
-  def map_test: ([Integer, Integer, Integer]) -> Array[String]
-  def map_bang_test: ([Integer, Integer, Integer]) -> (Array[Integer | String])
-  def map_bang_test_known_bug: ([Integer, Integer, Integer]) -> [Integer, Integer, Integer]
+  def map_test: ([Integer, Integer, Integer] a) -> Array[String]
+  def map_bang_test: ([Integer, Integer, Integer] a) -> (Array[Integer | String])
+  def map_bang_test_known_bug: ([Integer, Integer, Integer] a) -> [Integer, Integer, Integer]
 end

data/smoke/array-mul.rb

@@ -13,6 +13,6 @@ __END__
 # Classes
 class Object
   private
-  def foo: ([Integer, Integer, Integer]) -> Array[Integer]
-  def bar: ([Integer, Integer, Integer]) -> String
+  def foo: ([Integer, Integer, Integer] a) -> Array[Integer]
+  def bar: ([Integer, Integer, Integer] a) -> String
 end

data/smoke/array-plus1.rb

@@ -7,5 +7,5 @@ __END__
 # Classes
 class Object
   private
-  def log: (Array[:sym | Integer | String]) -> nil
+  def log: (Array[:sym | Integer | String] x) -> nil
 end

data/smoke/array-plus2.rb

@@ -11,5 +11,6 @@ __END__
 # Classes
 class Foo
   @var: Array[Integer]
+
   def foo: -> Array[Integer]
 end

data/smoke/array-range-aref.rb

@@ -57,15 +57,15 @@ __END__
 # Classes
 class Object
   private
-  def f1: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f2: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f3: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f4: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f5: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f6: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f7: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f8: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f9: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def f10: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
-  def dispatch: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f1: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f2: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f3: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f4: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f5: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f6: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f7: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f8: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f9: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def f10: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
+  def dispatch: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
 end

data/smoke/array-replace.rb

@@ -9,5 +9,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  def foo: ([Integer, Integer, Integer] a) -> (Array[Integer | String])
 end