typeprof 0.12.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 239b17dbe8d61c729346c5dde966f6abff491951c88bc33c57c4c34cc99dc497
-  data.tar.gz: 2696c83796a6af5c498cca59a3d98b7faccaf187fe60c0057ac3f052622009ff
+  metadata.gz: dcefd3a4da176820246ad53757286aa1f7f8b2d21a6d1300763c91ba252e95ca
+  data.tar.gz: 1bf7429a4cf7d59e1ab4ca10f5f065a22b85adbbda922c67060d0ede64aab60f
 SHA512:
-  metadata.gz: 23a7a3313dadd2d0c63a5d83a3afd112893134a049861e6a9e11cf5097aaa78c19494326b6a07b44cf4d93f5dec5a2c893b91fe2c4f5571726229d1e8dc13229
-  data.tar.gz: 3273f1bb24290af32db23aaae8cafa84905d4d2d576b5ab96178130fe843b73e4365827b60d47a022a2812621f7fe09a3801c32c205c9805516873ed9ac88659
+  metadata.gz: ff14f14aa923ca807db9d7f1bc7f537c46e735bd194a0b59758dfdba0e04c04175ca0505fe6c00f739fec7933eeeab5010646891f56e14d5245f5b8613dd7d3b
+  data.tar.gz: 73a05bece353a7b4dbefba9f16e723fb088795e9f029b143721b03543e53ae19a8adb9908b3de41c839fbfb10a8d34c76ed0fa4f1b072801d7334233be63b1c9

data/Gemfile.lock

@@ -1,25 +1,25 @@
 PATH
   remote: .
   specs:
-    typeprof (0.12.0)
-      rbs (>= 1.0.0)
+    typeprof (0.15.0)
+      rbs (>= 1.3.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coverage-helpers (1.0.0)
-    docile (1.3.4)
-    power_assert (1.2.0)
+    docile (1.4.0)
+    power_assert (2.0.0)
     rake (13.0.1)
-    rbs (1.0.3)
-    simplecov (0.20.0)
+    rbs (1.3.1)
+    simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
-    simplecov_json_formatter (0.1.2)
-    stackprof (0.2.16)
-    test-unit (3.3.7)
+    simplecov_json_formatter (0.1.3)
+    stackprof (0.2.17)
+    test-unit (3.4.2)
       power_assert
 
 PLATFORMS
@@ -36,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.2.3
+   2.2.15

data/lib/typeprof/analyzer.rb

@@ -42,6 +42,10 @@ module TypeProf
         "<builtin>"
       end
     end
+
+    def replace_cref(cref)
+      Context.new(@iseq, cref, @mid)
+    end
   end
 
   class TypedContext
@@ -61,6 +65,10 @@ module TypeProf
         "<typed-context:#{ @mid }>"
       end
     end
+
+    def replace_cref(cref)
+      # What to do?
+    end
   end
 
   class ExecutionPoint
@@ -86,6 +94,10 @@ module TypeProf
       ExecutionPoint.new(@ctx, @pc + 1, @outer)
     end
 
+    def replace_cref(cref)
+      ExecutionPoint.new(@ctx.replace_cref(cref), @pc, @outer)
+    end
+
     def source_location
       @ctx.source_location(@pc)
     end
@@ -238,6 +250,8 @@ module TypeProf
     end
 
     def initialize
+      @entrypoints = []
+
       @worklist = Utils::WorkList.new
 
       @ep2env = {}
@@ -263,16 +277,22 @@ module TypeProf
       @pending_execution = {}
       @executed_iseqs = Utils::MutableSet.new
 
-      @loaded_features = {}
+      @loaded_files = {}
 
       @rbs_reader = RBSReader.new
 
       @terminated = false
 
       @anonymous_struct_gen_id = 0
+
+      @types_being_shown = []
+    end
+
+    def add_entrypoint(iseq)
+      @entrypoints << iseq
     end
 
-    attr_reader :return_envs, :loaded_features, :rbs_reader
+    attr_reader :return_envs, :loaded_files, :rbs_reader
 
     def get_env(ep)
       @ep2env[ep]
@@ -311,9 +331,10 @@ module TypeProf
         @cvars = VarTable.new
         @absolute_path = absolute_path
         @namespace = nil
+        @subclasses = []
       end
 
-      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path, :subclasses
       attr_accessor :name, :klass_obj
 
       def mix_module(kind, mod, type_args, singleton, absolute_path)
@@ -427,6 +448,7 @@ module TypeProf
       idx = @class_defs.size
       if superclass
         @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
+        @class_defs[superclass.idx].subclasses << idx unless superclass == :__root__
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
@@ -453,6 +475,7 @@ module TypeProf
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
       @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
+      #@class_defs[superclass.idx].subclasses << idx # needed?
       klass = Type::Class.new(:class, idx, [], superclass, name)
       add_superclass_type_args!(klass, [Type.any])
       @class_defs[idx].klass_obj = klass
@@ -508,6 +531,13 @@ module TypeProf
       end
     end
 
+    def traverse_subclasses(klass, &blk)
+      @class_defs[klass.idx].subclasses.each do |subclass|
+        yield @class_defs[subclass]
+        traverse_subclasses(@class_defs[subclass].klass_obj, &blk)
+      end
+    end
+
     def search_method(klass, singleton, mid, &blk)
       # XXX: support method alias correctly
       klass_orig = klass
@@ -527,7 +557,18 @@ module TypeProf
       end
     end
 
-    def get_method(klass, singleton, mid)
+    def get_method(klass, singleton, include_subclasses, mid)
+      if include_subclasses
+        subclasses_mthds = []
+        traverse_subclasses(klass) do |subclass|
+          subclass.search_method(singleton, mid, {}) do |mthds,|
+            subclasses_mthds.concat(mthds.to_a)
+          end
+        end
+        search_method(klass, singleton, mid) {|mthds,| return subclasses_mthds + mthds.to_a }
+        return subclasses_mthds
+      end
+
       search_method(klass, singleton, mid) {|mthds,| return mthds }
     end
 
@@ -628,9 +669,10 @@ module TypeProf
       if klass == Type.any
         self
       else
-        mdefs = get_method(klass, singleton, orig_mid)
+        mdefs = get_method(klass, singleton, false, orig_mid) # XXX: include_subclass == false??
         if mdefs
-          mdefs.each do |mdef|
+          # dup is needed for `alias foo foo` (otherwise, "can't add a new key into hash during iteration" error occurs)
+          mdefs.dup.each do |mdef|
             @class_defs[klass.idx].add_method(alias_mid, singleton, AliasMethodDef.new(orig_mid, mdef, ep))
           end
         end
@@ -737,24 +779,32 @@ module TypeProf
       end
     end
 
-    def get_ivar(recv)
+    def identify_class_for_ivar(recv, var)
+      klass, singleton = recv.method_dispatch_info
+      return nil unless klass
+      search_method(klass, singleton, var) do |mthds, klass0, singleton0|
+        if mthds.any? {|mthd| mthd.is_a?(AttrMethodDef) }
+          return klass0, singleton
+        end
+      end
+      return klass, singleton
+    end
+
+    def get_ivar(recv, var)
       recv = recv.base_type while recv.respond_to?(:base_type)
-      case recv
-      when Type::Class
-        [@class_defs[recv.idx], true]
-      when Type::Instance
-        [@class_defs[recv.klass.idx], false]
-      when Type::Any
-        return
+
+      klass, singleton = identify_class_for_ivar(recv, var.to_s[1..].to_sym) # search attr_reader
+
+      if klass
+        return @class_defs[klass.idx], singleton
       else
-        warn "???"
-        return
+        return nil
       end
     end
 
     def add_ivar_read!(recv, var, ep, &ctn)
       recv.each_child do |recv|
-        class_def, singleton = get_ivar(recv)
+        class_def, singleton = get_ivar(recv, var)
         next unless class_def
         class_def.ivars.add_read!([singleton, var], ep, &ctn)
       end
@@ -762,7 +812,7 @@ module TypeProf
 
     def add_ivar_write!(recv, var, ty, ep)
       recv.each_child do |recv|
-        class_def, singleton = get_ivar(recv)
+        class_def, singleton = get_ivar(recv, var)
         next unless class_def
         class_def.ivars.add_write!([singleton, var], ty, ep, self)
       end
@@ -878,56 +928,77 @@ module TypeProf
       iter_counter = 0
       stat_eps = Utils::MutableSet.new
 
-      while true
-        until @worklist.empty?
-          ep = @worklist.deletemin
-
-          iter_counter += 1
-          if Config.options[:show_indicator]
-            tick2 = Time.now
-            if tick2 - tick >= 1
-              tick = tick2
-              $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
-              $stderr.flush
+      prologue_ctx = Context.new(nil, nil, nil)
+      prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
+      prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
+
+      until @entrypoints.empty?
+        entrypoint = @entrypoints.shift
+        if entrypoint.is_a?(String)
+          file = entrypoint
+          next if @loaded_files[File.expand_path(file)]
+          iseq = ISeq.compile(file)
+        else
+          iseq = entrypoint
+        end
+
+        @loaded_files[iseq.absolute_path] = true
+        ep, env = TypeProf.starting_state(iseq)
+        merge_env(ep, env)
+        add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
+
+        while true
+          until @worklist.empty?
+            ep = @worklist.deletemin
+
+            iter_counter += 1
+            if Config.options[:show_indicator]
+              tick2 = Time.now
+              if tick2 - tick >= 1
+                tick = tick2
+                $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
+                $stderr.flush
+              end
             end
-          end
 
-          if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
-            @terminated = true
-            break
-          end
+            if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
+              @terminated = true
+              break
+            end
 
-          stat_eps << ep
-          step(ep)
-        end
+            stat_eps << ep
+            step(ep)
+          end
 
-        break if @terminated
+          break if @terminated
 
-        break unless Config.options[:stub_execution]
+          break unless Config.options[:stub_execution]
 
-        begin
-          iseq, (kind, dummy_continuation) = @pending_execution.first
-          break if !iseq
-          @pending_execution.delete(iseq)
-        end while @executed_iseqs.include?(iseq)
+          begin
+            iseq, (kind, dummy_continuation) = @pending_execution.first
+            break if !iseq
+            @pending_execution.delete(iseq)
+          end while @executed_iseqs.include?(iseq)
 
-        puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
+          puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
 
-        break if !iseq
-        case kind
-        when :method
-          meth, ep, env = dummy_continuation
-          merge_env(ep, env)
-          add_iseq_method_call!(meth, ep.ctx)
-
-        when :block
-          blk, epenvs = dummy_continuation
-          epenvs.each do |ep, env|
+          break if !iseq
+          case kind
+          when :method
+            meth, ep, env = dummy_continuation
             merge_env(ep, env)
-            add_block_to_ctx!(blk.block_body, ep.ctx)
+            add_iseq_method_call!(meth, ep.ctx)
+
+          when :block
+            blk, epenvs = dummy_continuation
+            epenvs.each do |ep, env|
+              merge_env(ep, env)
+              add_block_to_ctx!(blk.block_body, ep.ctx)
+            end
           end
         end
       end
+
       $stderr.print "\r\e[K" if Config.options[:show_indicator]
 
       stat_eps
@@ -1245,7 +1316,13 @@ module TypeProf
             end
             if cbase.is_a?(Type::Class)
               klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
-              add_superclass_type_args!(klass, superclass.type_params.map { Type.any }) if superclass
+              if superclass
+                add_superclass_type_args!(klass, superclass.type_params.map { Type.any })
+
+                # inherited hook
+                aargs = ActualArguments.new([klass], nil, {}, Type.nil)
+                do_send(superclass, :inherited, aargs, ep, env) {|_ret_ty, _ep| }
+              end
             else
               klass = Type.any
             end
@@ -1280,15 +1357,13 @@ module TypeProf
       when :send
         env, recvs, mid, aargs = setup_actual_arguments(:method, operands, ep, env)
         recvs = Type.any if recvs == Type.bot
-        recvs.each_child do |recv|
-          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
-            nenv, ret_ty, = localize_type(ret_ty, env, ep)
-            nenv = nenv.push(ret_ty)
-            merge_env(ep.next, nenv)
-          end
+        do_send(recvs, mid, aargs, ep, env) do |ret_ty, ep, env|
+          nenv, ret_ty, = localize_type(ret_ty, env, ep)
+          nenv = nenv.push(ret_ty)
+          merge_env(ep.next, nenv)
         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
@@ -1316,28 +1391,59 @@ 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)
         recvs = Type.any if recvs == Type.bot
-        recvs.each_child do |recv|
-          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
-            env, ret_ty, = localize_type(ret_ty, env, ep)
+        do_send(recvs, mid, aargs, 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)
+          branchtype, target, = branch_operands
+          # branchtype: :if or :unless or :nil
+          ep_then = ep.next
+          ep_else = ep.jump(target)
 
-            case ret_ty
-            when Type::Instance.new(Type::Builtin[:true])
-              merge_env(branchtype == :if ? ep_else : ep_then, env)
-            when Type::Instance.new(Type::Builtin[:false])
-              merge_env(branchtype == :if ? ep_then : ep_else, env)
-            else
-              merge_env(ep_then, env)
-              merge_env(ep_else, env)
-            end
+          case ret_ty
+          when Type::Instance.new(Type::Builtin[:true])
+            merge_env(branchtype == :if ? ep_else : ep_then, env)
+          when Type::Instance.new(Type::Builtin[:false])
+            merge_env(branchtype == :if ? ep_then : ep_else, env)
+          else
+            merge_env(ep_then, env)
+            merge_env(ep_else, env)
           end
         end
         return
@@ -1371,12 +1477,10 @@ module TypeProf
               # XXX: this decomposition is really needed??
               # It calls `Object.new` with union receiver which causes an error, but
               # it may be a fault of builtin Object.new implementation.
-              recv.each_child do |recv|
-                meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
-                  nenv, ret_ty, = localize_type(ret_ty, env, ep)
-                  nenv = nenv.push(ret_ty)
-                  merge_env(ep.next, nenv)
-                end
+              meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
+                nenv, ret_ty, = localize_type(ret_ty, env, ep)
+                nenv = nenv.push(ret_ty)
+                merge_env(ep.next, nenv)
               end
             end
           end
@@ -1419,7 +1523,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)
@@ -1778,8 +1882,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)
@@ -2062,39 +2168,41 @@ module TypeProf
       return env, recv, mid, aargs
     end
 
-    def do_send(recv, mid, aargs, ep, env, &ctn)
-      case recv
-      when Type::Void
-        error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-        ctn[Type.any, ep, env]
-      when Type::Any
-        ctn[Type.any, ep, env]
-      else
-        klass, singleton = recv.method_dispatch_info
-        meths = get_method(klass, singleton, mid) if klass
-        if meths
-          meths.each do |meth|
-            meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
-          end
+    def do_send(recvs, mid, aargs, ep, env, &ctn)
+      recvs.each_child do |recv|
+        case recv
+        when Type::Void
+          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+          ctn[Type.any, ep, env]
+        when Type::Any
+          ctn[Type.any, ep, env]
         else
-          meths = get_method(klass, singleton, :method_missing) if klass
+          klass, singleton, include_subclasses = recv.method_dispatch_info
+          meths = get_method(klass, singleton, include_subclasses, mid) if klass
           if meths
-            aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
             meths.each do |meth|
-              meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+              meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
             end
           else
-            error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-            ctn[Type.any, ep, env]
+            meths = get_method(klass, singleton, include_subclasses, :method_missing) if klass
+            if meths
+              aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
+              meths.each do |meth|
+                meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+              end
+            else
+              error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+              ctn[Type.any, ep, env]
+            end
           end
         end
       end
     end
 
-    def do_invoke_block(blk, aargs, ep, env, replace_recv_ty: nil, &ctn)
+    def do_invoke_block(blk, aargs, ep, env, replace_recv_ty: nil, replace_cref: nil, &ctn)
       blk.each_child do |blk|
         if blk.is_a?(Type::Proc)
-          blk.block_body.do_call(aargs, ep, env, self, replace_recv_ty: replace_recv_ty, &ctn)
+          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")
           ctn[Type.any, ep, env]
@@ -2170,7 +2278,11 @@ module TypeProf
           next unless @block_to_ctx[blk.block_body] # this occurs when screen_name is called before type-profiling finished (e.g., error message)
           @block_to_ctx[blk.block_body].each do |blk_ctx|
             if farg_tys
-              farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
+              if @method_signatures[blk_ctx]
+                farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
+              else
+                # this occurs when screen_name is called before type-profiling finished (e.g., error message)
+              end
             else
               farg_tys = @method_signatures[blk_ctx]
             end
@@ -2180,17 +2292,24 @@ module TypeProf
         end
       end
 
-      farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
-      ret_ty = ret_ty.screen_name(self)
-      ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
+      return Type.any.screen_name(self) if @types_being_shown.include?(farg_tys) || @types_being_shown.include?(ret_ty)
+
+      begin
+        @types_being_shown << farg_tys << ret_ty
+        farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
+        ret_ty = ret_ty.screen_name(self)
+        ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
-      farg_tys = farg_tys + " " if farg_tys != ""
-      "^#{ farg_tys }-> #{ ret_ty }"
+        farg_tys = farg_tys + " " if farg_tys != ""
+        "^#{ farg_tys }-> #{ ret_ty }"
+      ensure
+        @types_being_shown.pop(2)
+      end
     end
 
     def show_method_signature(ctx)
       farg_tys = @method_signatures[ctx]
-      ret_ty = @return_values[ctx] || Type.bot
+      ret_ty = ctx.mid == :initialize ? Type::Void.new : @return_values[ctx] || Type.bot
 
       untyped = farg_tys.include_untyped?(self) || ret_ty.include_untyped?(self)