typeprof 0.14.0 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c03cc70d70c73d14871e07c098b0689e11afc8e309662a8d4402c6f2ecbc5d02
-  data.tar.gz: '097a04710ef19e6c8f29304c901dd8569e9e74a436dd1d76a5bf515df7fdfa41'
+  metadata.gz: c31fc03c67fa15924e901b70890318e2391fa58cfaf897e51ff6a00d673d792a
+  data.tar.gz: c6ce703ec1c5f8a41d04603162746adb8a9416ccf29abc8ef1441cf83a3b41e3
 SHA512:
-  metadata.gz: f5348942872848edec6b679db2a9afa60b746a6d3908f7066dfcd3a551d04ab728ea1494a5bdcf66867d7bc47ba0dce6ce29e2d29833babb5413262c8da92ca1
-  data.tar.gz: 9b214f8a4a24fa433a9c3d7fb205246b161c723206a73db257eb57b3905b34ab7ef378324a7786b63daccdf763616667c2d5d6fcbaf98ff6ff455f26f956082e
+  metadata.gz: 790815f2528442ae742df0c3576a97ff6d2c856db374f2c8a63bb965dd6c715b6fa686d84b1fd56683e938e9c8e4014e9e86b53bb34ca4e9975b93bb5e5188df
+  data.tar.gz: ecc1433a74aebbe31c267c4697d71389a841cd66d74b251d1cc2d22bbeca228f141a8861ecbeebee3b16d54a8397f41eeab4f1f25ebac42103aee5e1146c9fe6

data/Gemfile.lock

@@ -1,25 +1,25 @@
 PATH
   remote: .
   specs:
-    typeprof (0.13.0)
-      rbs (>= 1.0.0)
+    typeprof (0.15.1)
+      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.3)
+    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

@@ -277,20 +277,23 @@ 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 = []
+      @namespace = nil
     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]
@@ -329,9 +332,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)
@@ -445,6 +449,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
@@ -471,6 +476,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
@@ -526,6 +532,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
@@ -545,7 +558,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
 
@@ -646,9 +670,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
@@ -755,24 +780,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
@@ -780,7 +813,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
@@ -901,7 +934,16 @@ module TypeProf
       prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
 
       until @entrypoints.empty?
-        iseq = @entrypoints.shift
+        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| }
@@ -1077,15 +1119,16 @@ module TypeProf
       env = @ep2env[ep]
       raise "nil env" unless env
 
-      insn, operands = ep.ctx.iseq.insns[ep.pc]
+      insn = ep.ctx.iseq.insns[ep.pc]
+      operands = insn.operands
 
       if Config.verbose >= 2
         # XXX: more dedicated output
         puts "DEBUG: stack=%p" % [env.stack]
-        puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn, env.stack.size]
+        puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn.insn, env.stack.size]
       end
 
-      case insn
+      case insn.insn
       when :_iseq_body_start
         # XXX: reconstruct and record the method signature
         iseq = ep.ctx.iseq
@@ -1316,12 +1359,10 @@ 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 :recv_getlocal_send_branch
@@ -1389,24 +1430,22 @@ module TypeProf
         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
@@ -1440,12 +1479,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
@@ -1606,7 +1643,7 @@ module TypeProf
           return
         end
 
-      when :getlocal, :getblockparam, :getblockparamproxy
+      when :getlocal
         var_idx, scope_idx, _escaped = operands
         if scope_idx == 0
           ty = env.get_local(-var_idx+2)
@@ -1647,18 +1684,12 @@ module TypeProf
         getlocal_operands, _dup_operands, branch_operands = operands
         var_idx, _scope_idx, _escaped = getlocal_operands
         ret_ty = env.get_local(-var_idx+2)
-        unless ret_ty
-          p env.locals
-          raise
-        end
 
         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
-
         ret_ty.each_child do |ret_ty|
           flow_env = env.local_update(-var_idx+2, ret_ty).push(ret_ty)
           case ret_ty
@@ -1672,6 +1703,31 @@ module TypeProf
           end
         end
         return
+      when :dup_setlocal_branch
+        _dup_operands, setlocal_operands, branch_operands = operands
+
+        env, (ret_ty,) = env.pop(1)
+
+        var_idx, _scope_idx, _escaped = setlocal_operands
+
+        branchtype, target, = branch_operands
+        # branchtype: :if or :unless or :nil
+        ep_then = ep.next
+        ep_else = ep.jump(target)
+
+        ret_ty.each_child do |ret_ty|
+          flow_env = env.local_update(-var_idx+2, ret_ty)
+          case ret_ty
+          when Type.any
+            merge_env(ep_then, flow_env)
+            merge_env(ep_else, flow_env)
+          when Type::Instance.new(Type::Builtin[:false]), Type.nil
+            merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+          else
+            merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+          end
+        end
+        return
       when :getlocal_checkmatch_branch
         getlocal_operands, branch_operands = operands
         var_idx, _scope_idx, _escaped = getlocal_operands
@@ -1935,7 +1991,7 @@ module TypeProf
         end
         env = env.push(ty)
       else
-        raise "Unknown insn: #{ insn }"
+        raise "Unknown insn: #{ insn.insn }"
       end
 
       add_edge(ep, ep)
@@ -2133,30 +2189,32 @@ 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
@@ -2167,7 +2225,7 @@ module TypeProf
         if blk.is_a?(Type::Proc)
           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")
+          warn(ep, "non-proc is passed as a block") if blk != Type.any
           ctn[Type.any, ep, env]
         end
       end
@@ -2241,7 +2299,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
@@ -2251,17 +2313,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)
 
-      farg_tys = farg_tys + " " if farg_tys != ""
-      "^#{ farg_tys }-> #{ 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 }"
+      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)