typeprof 0.7.0 → 0.10.0

data/lib/typeprof/iseq.rb

@@ -49,10 +49,18 @@ module TypeProf
         insns[i, 0] = [[:_iseq_body_start]]
       end
 
+      # 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
+
       @insns = []
       @linenos = []
 
-      labels = setup_iseq(insns)
+      labels = setup_iseq(insns, special_labels)
 
       # checkmatch->branch
       # send->branch
@@ -60,7 +68,8 @@ module TypeProf
       @catch_table = []
       catch_table.map do |type, iseq, first, last, cont, stack_depth|
         iseq = iseq ? ISeq.new(iseq) : nil
-        entry = [type, iseq, labels[cont], stack_depth]
+        target = labels[special_labels[cont] ? :"#{ cont }_special" : cont]
+        entry = [type, iseq, target, stack_depth]
         labels[first].upto(labels[last]) do |i|
           @catch_table[i] ||= []
           @catch_table[i] << entry
@@ -76,19 +85,26 @@ module TypeProf
       @id <=> other.id
     end
 
-    def setup_iseq(insns)
+    def setup_iseq(insns, special_labels)
       i = 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
-        elsif e.is_a?(Array)
-          i += 1
+        else
+          i += 1 if e.is_a?(Array)
+          ninsns << e
         end
       end
 
       lineno = 0
-      insns.each do |e|
+      ninsns.each do |e|
         case e
         when Integer # lineno
           lineno = e
@@ -191,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
@@ -200,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
@@ -208,13 +224,32 @@ module TypeProf
           end
         end
       end
-      send_branch_list.each do |i, j|
-        next if (i + 1 .. j).any? {|i| branch_targets[i] }
+      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,14 +1,17 @@
 module TypeProf
   class MethodDef
+    attr_accessor :pub_meth
+
     include Utils::StructuralEquality
   end
 
   class ISeqMethodDef < MethodDef
-    def initialize(iseq, cref, outer_ep)
+    def initialize(iseq, cref, outer_ep, pub_meth)
       @iseq = iseq
       raise if iseq.nil?
       @cref = cref
       @outer_ep = outer_ep
+      @pub_meth = pub_meth
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
@@ -27,7 +30,7 @@ module TypeProf
 
       nctx = Context.new(@iseq, @cref, mid)
       callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
-      nenv = Env.new(StaticEnv.new(recv, blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      nenv = Env.new(StaticEnv.new(recv, blk_ty, false, true), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       locals.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(i)
@@ -84,24 +87,23 @@ module TypeProf
       # XXX: need to check .rbs msig and .rb fargs
 
       ctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(ctx, 0, nil)
+      callee_ep = ExecutionPoint.new(ctx, 0, @outer_ep)
 
       locals = [Type.nil] * @iseq.locals.size
-      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false, true), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       idx = 0
       msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
-        # nenv is top-level, so it is okay to call Type#localize directly
         ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(i, ty)
       end
       if msig.opt_tys
         msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(lead_num + i, ty)
         end
       end
@@ -109,27 +111,27 @@ module TypeProf
         alloc_site2 = alloc_site.add_id(idx += 1)
         ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
         ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-        nenv, rest_ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv, rest_ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(rest_start, rest_ty)
       end
       if msig.post_tys
         msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
           ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
-      if msig.kw_tys
+      if msig.kw_tys && keyword # TODO: support the case where RBS writes kw_tys and RB method accepts **kwrest
         msig.kw_tys.each do |_, key, ty|
-          i = keyword.index(key)
+          i = keyword.index {|callee_key,| callee_key == key }
           unless i
             # warn
             next
           end
           alloc_site2 = alloc_site.add_id(key)
           ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
@@ -137,34 +139,55 @@ module TypeProf
         ty = msig.kw_rest_ty
         alloc_site2 = alloc_site.add_id(:**)
         ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
-        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(kw_rest, ty)
       end
       nenv = nenv.local_update(block_start, msig.blk_ty) if block_start
 
       opt.each do |start_pc|
-        scratch.merge_env(ExecutionPoint.new(ctx, start_pc, nil), nenv)
+        scratch.merge_env(callee_ep.jump(start_pc), nenv)
       end
+      scratch.add_executed_iseq(@iseq)
 
       ctx
     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
       when :reader
         if aargs.lead_tys.size == 0
-          scratch.get_instance_variable(recv, @ivar, caller_ep, caller_env) do |ty, nenv|
-            ctn[ty, caller_ep, nenv]
+          scratch.add_ivar_read!(recv, @ivar, caller_ep) do |ty, _ep|
+            ctn[ty, caller_ep, caller_env]
           end
         else
           ctn[Type.any, caller_ep, caller_env]
@@ -182,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
@@ -224,7 +248,7 @@ module TypeProf
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
           s_recv = recv
           s_recv = s_recv.base_type while s_recv.respond_to?(:base_type)
-          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
+          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false, true), [], [], Utils::HashWrapper.new({}))
           if msig.blk_ty.is_a?(Type::Proc)
             scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
             bsig = msig.blk_ty.block_body.msig
@@ -283,12 +307,12 @@ 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)
-      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env } # for Kernel#lambda
       @impl[recv, mid, aargs, caller_ep, caller_env, scratch, &ctn]
     end
   end

data/lib/typeprof/type.rb

@@ -315,9 +315,14 @@ module TypeProf
       def globalize(env, visited, depth)
         return Type.any if depth <= 0
         tys = Utils::Set[]
-        raise if @elems
+        if @elems
+          # XXX: If @elems is non nil, the Union type should global, so calling globalize against such a type should not occur.
+          # However, currently, ActualArguments may contain global types for flag_args_kw_splat case.
+          # This should be fixed in future in ActualArguments side. See Scratch#setup_actual_arguments.
+          #raise
+        end
 
-        elems = {}
+        elems = @elems ? @elems.dup : {}
         @types.each do |ty|
           ty = ty.globalize(env, visited, depth - 1)
           case ty
@@ -435,17 +440,17 @@ module TypeProf
     end
 
     class Class < Type # or Module
-      def initialize(kind, idx, type_params, superclass, superclass_type_args, name)
+      def initialize(kind, idx, type_params, superclass, name)
         @kind = kind # :class | :module
         @idx = idx
         @type_params = type_params
         @superclass = superclass
         raise if @kind == :class && !@superclass
-        @superclass_type_args = superclass_type_args
         @_name = name
       end
 
-      attr_reader :kind, :idx, :type_params, :superclass, :superclass_type_args
+      attr_reader :kind, :idx, :type_params, :superclass
+      attr_accessor :superclass_type_args
 
       def inspect
         if @_name
@@ -492,6 +497,8 @@ module TypeProf
       def initialize(klass)
         raise unless klass
         raise if klass == Type.any
+        raise if klass.is_a?(Type::Instance)
+        raise if klass.is_a?(Type::Union)
         @klass = klass
       end
 
@@ -682,6 +689,8 @@ module TypeProf
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:int]))
       when ::Rational
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:rational]))
+      when ::Complex
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:complex]))
       when ::Float
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:float]))
       when ::Class
@@ -718,6 +727,8 @@ module TypeProf
         Type.nil
       when ::Range
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:range]))
+      when ::Encoding
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:encoding]))
       else
         raise "unknown object: #{ obj.inspect }"
       end
@@ -770,31 +781,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
-      str = str.empty? ? "" : "(#{ str.join(", ") })"
+      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
+      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 = []
@@ -807,12 +843,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
 
@@ -820,12 +856,16 @@ module TypeProf
     def initialize(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
       @lead_tys = lead_tys
       @opt_tys = opt_tys
+      raise unless opt_tys.is_a?(Array)
       @rest_ty = rest_ty
       @post_tys = post_tys
       raise unless post_tys
       @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
 
@@ -842,6 +882,44 @@ module TypeProf
       MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
 
+    def merge_as_block_arguments(other)
+      lead_tys1, opt_tys1, rest_ty1, post_tys1 = @lead_tys, @opt_tys, @rest_ty, @post_tys
+      lead_tys2, opt_tys2, rest_ty2, post_tys2 = other.lead_tys, other.opt_tys, other.rest_ty, other.post_tys
+
+      case
+      when lead_tys1.size > lead_tys2.size
+        n = lead_tys2.size
+        lead_tys1, opt_tys1 = lead_tys1[0, n], lead_tys1[n..] + opt_tys1
+      when lead_tys1.size < lead_tys2.size
+        n = lead_tys1.size
+        lead_tys2, opt_tys2 = lead_tys2[0, n], lead_tys2[n..] + opt_tys2
+      end
+      case
+      when post_tys1.size > post_tys2.size
+        i = post_tys1.size - post_tys2.size
+        if rest_ty1
+          rest_ty1 = post_tys[0, i].inject(rest_ty1) {|ty1, ty2| ty1.union(ty2) }
+          post_tys1 = post_tys1[i..]
+        else
+          opt_tys1, post_tys1 = opt_tys1 + post_tys1[0, i], post_tys1[i..]
+        end
+      when post_tys1.size < post_tys2.size
+        i = post_tys2.size - post_tys1.size
+        if rest_ty2
+          rest_ty2 = post_tys[0, i].inject(rest_ty2) {|ty1, ty2| ty1.union(ty2) }
+          post_tys2 = post_tys2[i..]
+        else
+          opt_tys2, post_tys2 = opt_tys2 + post_tys2[0, i], post_tys2[i..]
+        end
+      end
+
+      # XXX: tweak keywords too
+
+      msig1 = MethodSignature.new(lead_tys1, opt_tys1, rest_ty1, post_tys1, @kw_tys, @kw_rest_ty, @blk_ty)
+      msig2 = MethodSignature.new(lead_tys2, opt_tys2, rest_ty2, post_tys2, other.kw_tys, other.kw_rest_ty, other.blk_ty)
+      msig1.merge(msig2)
+    end
+
     def merge(other)
       raise if @lead_tys.size != other.lead_tys.size
       raise if @post_tys.size != other.post_tys.size