typeprof 0.5.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d60066fe3965ec65f9885e311f856277d0e41330478489c026fdf6b387ba2ba
-  data.tar.gz: 963b66fe97d98207d72645011bcd012368937ded76278d92a4b677b961c92cdc
+  metadata.gz: 1c3bf54ec6fee3b06397893d2f10f1fae8e7af82b8f1640a4ddd305c33922ff7
+  data.tar.gz: 944d40a75789b4805e53ca70e169fe68fcd4dbca7f24bc4ccc779964085e980d
 SHA512:
-  metadata.gz: a40e89e05c1680480eb66798863ab99a4b38b3faaacdc471a6cdd45dfc1f897efcc8f613800ef28e5bc722c3504dec510ca943435873b6cb765a27f1bb073425
-  data.tar.gz: 94dddf2c3e465ee19093ce571d50440293118b07ab7c90203aa5ccb40c4f9eb9afe1059eff045c965006affa8f0d66d141be2064feddf9a2b1f8384f8cadae64
+  metadata.gz: 726cdbfcda694f189a96f3f35088cbcbd9a3064e79e3838f7758d7bc393bf8591c0559db1c17993f971f9ae2ee4ca3b4c09f5c0ef6d6675752b00b6948cdfe62
+  data.tar.gz: b2b7353855183df391d8bc78c247eb7de09c1b65b2753789eb1e1fb0208275d10fec6d2d95745f36771de30af5e32281476100a0654db6f7cf87c8e442b36a65

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.5.4)
-      rbs (>= 0.17.0)
+    typeprof (0.9.0)
+      rbs (>= 0.20.0)
 
 GEM
   remote: https://rubygems.org/
@@ -11,13 +11,15 @@ GEM
     docile (1.3.2)
     power_assert (1.2.0)
     rake (13.0.1)
-    rbs (0.17.0)
-    simplecov (0.19.1)
+    rbs (0.20.1)
+    simplecov (0.20.0)
       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.6)
+    test-unit (3.3.7)
       power_assert
 
 PLATFORMS

data/doc/doc.ja.md

@@ -35,10 +35,9 @@ $ typeprof sig/app.rbs app.rb -o sig/app.gen.rbs
 * `--exclude-dir DIR`: `DIR`以下のファイルの解析結果を出力から省略する。後に指定されているほうが優先される（`--include-dir foo --exclude-dir foo/bar`の場合う、foo/bar/baz.rbの結果は出力されず、foo/baz.rbの結果は出力される）。
 * `--include-dir DIR`: `DIR`以下のファイルの解析結果を出力に含める。後に指定されているほうが優先される（`--exclude-dir foo --include-dir foo/bar`の場合、
 foo/bar/baz.rbの結果は出力されるが、foo/baz.rbの結果は出力されない）。
-* `-fshow-errors`: 実行中に見つけたバグの可能性を出力します（多くの場合、大量のfalse positiveが出ます）。
-* `-fpedantic-output`: デフォルトでは`A | untyped`と推定されたところを単に`A`と出力しますが、より生の出力、つまり`A | untyped`と出力します。
-* `-fshow-container-raw-elements`: （後で書く）
-* `-ftype-depth-limit=NUM`: （後で書く）
+* `--show-errors`: 実行中に見つけたバグの可能性を出力します（多くの場合、大量のfalse positiveが出ます）。
+* `--show-untyped`: デフォルトでは`A | untyped`と推定されたところを単に`A`と出力しますが、より生の出力、つまり`A | untyped`と出力します。
+* `--type-depth-limit=NUM`: （後で書く）
 
 ## TypeProfとは
 

data/doc/doc.md

@@ -34,10 +34,9 @@ Here is a list of currently avaiable options:
 * `-r GEMNAME`: Load the RBS files of `GEMNAME`
 * `--exclude-dir DIR`: Omit the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--include-dir foo --exclude-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is omitted, but foo/baz.rb is shown.)
 * `--include-dir DIR`: Show the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--exclude-dir foo --include-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is shown, but foo/baz.rb is omitted.)
-* `-fshow-errors`: Prints out possible bugs found during execution (often a lot of false positives).
-* `-fpedantic-output`: When TypeProf inferred a type `A | untyped`, it simply outputs `A` by default. But this option forces it to output `A | untyped`.
-* `-fshow-container-raw-elements`: (undocumented yet)
-* `-ftype-depth-limit=NUM`: (undocumented yet)
+* `--show-errors`: Prints out possible bugs found during execution (often a lot of false positives).
+* `--show-untyped`: When TypeProf infers a type `A | untyped`, it simply outputs `A` by default. But this option forces to output `A | untyped`.
+* `--type-depth-limit=NUM`: (undocumented yet)
 
 ## What is a TypeProf?
 

data/lib/typeprof/analyzer.rb

@@ -34,6 +34,14 @@ module TypeProf
     end
 
     attr_reader :iseq, :cref, :mid
+
+    def source_location(pc)
+      if @iseq
+        @iseq.source_location(pc)
+      else
+        "<builtin>"
+      end
+    end
   end
 
   class TypedContext
@@ -45,6 +53,14 @@ module TypeProf
     end
 
     attr_reader :caller_ep, :mid
+
+    def source_location(_pc)
+      if @caller_ep
+        @caller_ep.source_location
+      else
+        "<typed-context:#{ @mid }>"
+      end
+    end
   end
 
   class ExecutionPoint
@@ -71,36 +87,33 @@ module TypeProf
     end
 
     def source_location
-      iseq = @ctx.iseq
-      if iseq
-        iseq.source_location(@pc)
-      else
-        "<builtin>"
-      end
+      @ctx.source_location(@pc)
     end
   end
 
   class StaticEnv
     include Utils::StructuralEquality
 
-    def initialize(recv_ty, blk_ty, mod_func)
+    def initialize(recv_ty, blk_ty, mod_func, pub_meth)
       @recv_ty = recv_ty
       @blk_ty = blk_ty
       @mod_func = mod_func
+      @pub_meth = pub_meth
 
       return if recv_ty == :top #OK
       recv_ty.each_child_global do |ty|
-        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && ty != Type.any
+        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && !ty.is_a?(Type::Symbol) && ty != Type.any
       end
     end
 
-    attr_reader :recv_ty, :blk_ty, :mod_func
+    attr_reader :recv_ty, :blk_ty, :mod_func, :pub_meth
 
     def merge(other)
       recv_ty = @recv_ty.union(other.recv_ty)
       blk_ty = @blk_ty.union(other.blk_ty)
       mod_func = @mod_func & other.mod_func # ??
-      StaticEnv.new(recv_ty, blk_ty, mod_func)
+      pub_meth = @pub_meth & other.pub_meth # ??
+      StaticEnv.new(recv_ty, blk_ty, mod_func, pub_meth)
     end
   end
 
@@ -185,29 +198,27 @@ module TypeProf
       Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
     end
 
-    def deploy_type(klass, alloc_site, elems, base_ty)
-      local_ty = klass.new(alloc_site, base_ty)
-      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
-      nenv = Env.new(@static_env, @locals, @stack, type_params)
-      return nenv, local_ty
-    end
-
     def get_container_elem_types(id)
       @type_params.internal_hash[id]
     end
 
-    def update_container_elem_types(id, elems)
+    def deploy_type(id, elems)
       type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ id => elems }))
       Env.new(@static_env, @locals, @stack, type_params)
     end
 
     def enable_module_function
-      senv = StaticEnv.new(@static_env.recv_ty, @static_env.blk_ty, true)
+      senv = StaticEnv.new(@static_env.recv_ty, @static_env.blk_ty, true, @static_env.pub_meth)
+      Env.new(senv, @locals, @stack, @type_params)
+    end
+
+    def method_public_set(flag)
+      senv = StaticEnv.new(@static_env.recv_ty, @static_env.blk_ty, @static_env.mod_func, flag)
       Env.new(senv, @locals, @stack, @type_params)
     end
 
     def replace_recv_ty(ty)
-      senv = StaticEnv.new(ty, @static_env.blk_ty, @static_env.mod_func)
+      senv = StaticEnv.new(ty, @static_env.blk_ty, @static_env.mod_func, @static_env.pub_meth)
       Env.new(senv, @locals, @stack, @type_params)
     end
 
@@ -281,11 +292,10 @@ module TypeProf
     attr_reader :class_defs
 
     class ClassDef # or ModuleDef
-      def initialize(kind, name, superclass, absolute_path)
+      def initialize(kind, name, absolute_path)
         raise unless name.is_a?(Array)
         @kind = kind
-        @superclass = superclass
-        @modules = { true => {}, false => {} }
+        @modules = { true => [], false => [] }
         @name = name
         @consts = {}
         @methods = {}
@@ -295,14 +305,16 @@ module TypeProf
         @namespace = nil
       end
 
-      attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, singleton, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[singleton][mod]
-        unless absolute_paths
-          @modules[singleton][mod] = absolute_paths = Utils::MutableSet.new
+      def include_module(mod, type_args, singleton, absolute_path)
+        mod_, module_type_args, absolute_paths = @modules[singleton].find {|m,| m == mod }
+        if mod_
+          raise "inconsistent include/extend type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
+        else
+          absolute_paths = Utils::MutableSet.new
+          @modules[singleton].unshift([mod, type_args, absolute_paths])
         end
         absolute_paths << absolute_path
       end
@@ -319,13 +331,29 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def get_method(mid, singleton)
-        @methods[[singleton, mid]] || begin
-          @modules[singleton].each_key do |mod|
-            meth = mod.get_method(mid, false)
-            return meth if meth
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+        mthds = @methods[[singleton, mid]]
+        yield subst, direct if mthds&.include?(mthd)
+        @modules[singleton].each do |mod_def, type_args,|
+          if mod_def.klass_obj.type_params && type_args
+            subst2 = {}
+            mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
           end
-          nil
+        end
+      end
+
+      def search_method(singleton, mid, visited, &blk)
+        # Currently, circular inclusion of modules is allowed
+        return if visited[self]
+        visited[self] = true
+        mthds = @methods[[singleton, mid]]
+        yield mthds, @klass_obj, singleton if mthds
+        @modules[singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, visited, &blk)
         end
       end
 
@@ -344,12 +372,16 @@ module TypeProf
       end
 
       def set_method(mid, singleton, mdef)
-        @methods[[singleton, mid]] = Utils::MutableSet.new
-        @methods[[singleton, mid]] << mdef
+        if mdef
+          @methods[[singleton, mid]] = Utils::MutableSet.new
+          @methods[[singleton, mid]] << mdef
+        else
+          @methods.delete([singleton, mid])
+        end
       end
     end
 
-    def include_module(including_mod, included_mod, singleton, absolute_path)
+    def include_module(including_mod, included_mod, type_args, singleton, caller_ep)
       return if included_mod == Type.any
 
       including_mod = @class_defs[including_mod.idx]
@@ -357,9 +389,9 @@ module TypeProf
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, singleton, absolute_path)
+            including_mod.include_module(included_mod, type_args, singleton, caller_ep ? caller_ep.ctx.iseq.absolute_path : nil)
           else
-            warn "including something that is not a module"
+            warn(caller_ep, "including something that is not a module")
           end
         end
       end
@@ -373,12 +405,7 @@ module TypeProf
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
-        if superclass == :__root__
-          superclass_idx = superclass = nil
-        else
-          superclass_idx = superclass.idx
-        end
-        @class_defs[idx] = ClassDef.new(:class, show_name, superclass_idx, absolute_path)
+        @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
@@ -386,7 +413,7 @@ module TypeProf
         return klass
       else
         # module
-        @class_defs[idx] = ClassDef.new(:module, show_name, nil, absolute_path)
+        @class_defs[idx] = ClassDef.new(:module, show_name, absolute_path)
         mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
         add_constant(cbase, name, mod, absolute_path)
@@ -394,14 +421,19 @@ module TypeProf
       end
     end
 
+    def add_superclass_type_args!(klass, tyargs)
+      klass.superclass_type_args = tyargs
+    end
+
     def new_struct(ep)
       return @struct_defs[ep] if @struct_defs[ep]
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
-      @class_defs[idx] = ClassDef.new(:class, [name], superclass.idx, ep.ctx.iseq.absolute_path)
+      @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
       klass = Type::Class.new(:class, idx, [], superclass, name)
+      add_superclass_type_args!(klass, [Type.any])
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -431,28 +463,77 @@ module TypeProf
       end
     end
 
+    def adjust_substitution(klass, singleton, mid, mthd, subst, &blk)
+      direct = true
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+          direct = false
+          if klass.superclass && klass.superclass_type_args
+            subst2 = {}
+            klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            subst = subst2
+          end
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+      end
+    end
+
+    def search_method(klass, singleton, mid, &blk)
+      # XXX: support method alias correctly
+      klass_orig = klass
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.search_method(singleton, mid, {}, &blk)
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.search_method(singleton, mid, {}, &blk)
+      end
+      if singleton
+        search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
+      end
+    end
+
     def get_method(klass, singleton, mid)
-      idx = klass.idx
-      while idx
-        class_def = @class_defs[idx]
-        mthd = class_def.get_method(mid, singleton)
-        # Need to be conservative to include all super candidates...?
-        return mthd if mthd
-        idx = class_def.superclass
+      search_method(klass, singleton, mid) {|mthds,| return mthds }
+    end
+
+    def get_all_super_methods(klass, singleton, current_klass, mid)
+      hit = false
+      search_method(klass, singleton, mid) do |mthds, klass0, singleton0|
+        yield mthds, klass0, singleton0 if hit
+        hit = klass0 == current_klass
       end
-      return get_method(Type::Builtin[:class], false, mid) if singleton
-      nil
     end
 
     def get_super_method(ctx, singleton)
-      idx = ctx.cref.klass.idx
+      klass = ctx.cref.klass
       mid = ctx.mid
-      idx = @class_defs[idx].superclass
-      while idx
-        class_def = @class_defs[idx]
+      if klass.kind == :class
+        klass = klass.superclass
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          mthd = class_def.get_method(mid, singleton)
+          return mthd if mthd
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
         mthd = class_def.get_method(mid, singleton)
         return mthd if mthd
-        idx = class_def.superclass
       end
       nil
     end
@@ -478,9 +559,7 @@ module TypeProf
     end
 
     def add_constant(klass, name, value, user_defined)
-      if klass == Type.any
-        self
-      else
+      if klass.is_a?(Type::Class)
         @class_defs[klass.idx].add_constant(name, value, user_defined)
       end
     end
@@ -508,12 +587,12 @@ module TypeProf
       end
     end
 
-    def add_iseq_method(klass, mid, iseq, cref)
-      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref))
+    def add_iseq_method(klass, mid, iseq, cref, outer_ep, pub_meth)
+      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
     end
 
-    def add_singleton_iseq_method(klass, mid, iseq, cref)
-      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref))
+    def add_singleton_iseq_method(klass, mid, iseq, cref, outer_ep, pub_meth)
+      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
     end
 
     def set_custom_method(klass, mid, impl)
@@ -546,6 +625,10 @@ module TypeProf
       @iseq_method_to_ctxs[iseq_mdef] << ctx
     end
 
+    def add_executed_iseq(iseq)
+      @executed_iseqs << iseq
+    end
+
     def add_callsite!(callee_ctx, caller_ep, caller_env, &ctn)
       @executed_iseqs << callee_ctx.iseq if callee_ctx.is_a?(Context)
 
@@ -605,7 +688,7 @@ module TypeProf
       def add_read!(site, ep, &ctn)
         entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new)
         entry.read_continuations[ep] = ctn
-        entry.absolute_paths << ep.ctx.iseq.absolute_path
+        entry.absolute_paths << ep.ctx.iseq.absolute_path if ep.ctx.is_a?(Context)
         ctn[entry.type, ep]
       end
 
@@ -664,6 +747,7 @@ module TypeProf
 
     def add_cvar_read!(klass, var, ep, &ctn)
       klass.each_child do |klass|
+        next unless klass.is_a?(Type::Class)
         class_def = @class_defs[klass.idx]
         next unless class_def
         class_def.cvars.add_read!(var, ep, &ctn)
@@ -672,6 +756,7 @@ module TypeProf
 
     def add_cvar_write!(klass, var, ty, ep)
       klass.each_child do |klass|
+        next unless klass.is_a?(Type::Class)
         class_def = @class_defs[klass.idx]
         next unless class_def
         class_def.cvars.add_write!(var, ty, ep, self)
@@ -722,7 +807,7 @@ module TypeProf
         merge_return_env(tmp_ep) do |menv|
           elems = menv.get_container_elem_types(id)
           elems = yield elems
-          menv = menv.update_container_elem_types(id, elems)
+          menv = menv.deploy_type(id, elems)
           gid = @alloc_site_to_global_id[id]
           if gid
             ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
@@ -734,7 +819,7 @@ module TypeProf
       else
         elems = env.get_container_elem_types(id)
         elems = yield elems
-        env = env.update_container_elem_types(id, elems)
+        env = env.deploy_type(id, elems)
         gid = @alloc_site_to_global_id[id]
         if gid
           ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
@@ -775,11 +860,11 @@ module TypeProf
           ep = @worklist.deletemin
 
           iter_counter += 1
-          if Config.verbose >= 1
+          if Config.options[:show_indicator]
             tick2 = Time.now
             if tick2 - tick >= 1
               tick = tick2
-              $stderr << "\rType Profiling... (%d steps @ %s)\e[K" % [iter_counter, ep.source_location]
+              $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
               $stderr.flush
             end
           end
@@ -795,9 +880,7 @@ module TypeProf
 
         break if @terminated
 
-        # XXX: it would be good to provide no-dummy-execution mode.
-        # It should work as a bit smarter "rbs prototype rb";
-        # show all method definitions as "untyped" arguments and return values
+        break unless Config.options[:stub_execution]
 
         begin
           iseq, (kind, dummy_continuation) = @pending_execution.first
@@ -805,7 +888,7 @@ module TypeProf
           @pending_execution.delete(iseq)
         end while @executed_iseqs.include?(iseq)
 
-        puts "DEBUG: trigger dummy 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
@@ -822,7 +905,7 @@ module TypeProf
           end
         end
       end
-      $stderr.print "\r\e[K" if Config.verbose >= 1
+      $stderr.print "\r\e[K" if Config.options[:show_indicator]
 
       stat_eps
     end
@@ -863,9 +946,9 @@ module TypeProf
       end
     end
 
-    def pend_method_execution(iseq, meth, recv, mid, cref)
+    def pend_method_execution(iseq, meth, recv, mid, cref, ep)
       ctx = Context.new(iseq, cref, mid)
-      ep = ExecutionPoint.new(ctx, 0, nil)
+      ep = ExecutionPoint.new(ctx, 0, ep)
       locals = [Type.nil] * iseq.locals.size
 
       fargs_format = iseq.fargs_format
@@ -900,17 +983,23 @@ module TypeProf
       locals[kwrest_index] = Type.any if kwrest_index
       locals[block_index] = Type.nil if block_index
 
-      env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
+      env = Env.new(StaticEnv.new(recv, Type.nil, false, true), locals, [], Utils::HashWrapper.new({}))
 
-      @pending_execution[iseq] ||= [:method, [meth, ep, env]]
+      if !@pending_execution[iseq] || @pending_execution[iseq][0] == :block
+        @pending_execution[iseq] = [:method, [meth, ep, env]]
+      end
     end
 
     def pend_block_dummy_execution(blk, iseq, nep, nenv)
       @pending_execution[iseq] ||= [:block, [blk, {}]]
-      if @pending_execution[iseq][1][1][nep]
-        @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
+      if @pending_execution[iseq][0] == :block
+        if @pending_execution[iseq][1][1][nep]
+          @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
+        else
+          @pending_execution[iseq][1][1][nep] = nenv
+        end
       else
-        @pending_execution[iseq][1][1][nep] = nenv
+        # XXX: what to do?
       end
     end
 
@@ -919,7 +1008,7 @@ module TypeProf
         alloc_site = AllocationSite.new(ep)
         nenv, ty = localize_type(ty, env, ep, alloc_site)
         case ty
-        when Type::LocalCell, Type::LocalArray, Type::LocalHash
+        when Type::Local
           @alloc_site_to_global_id[ty.id] = [recv, var] # need overwrite check??
         end
         yield ty, nenv
@@ -959,7 +1048,7 @@ module TypeProf
         block_start = iseq.fargs_format[:block_start]
 
         lead_tys = env.locals[0, lead_num].map {|ty| globalize_type(ty, env, ep) }
-        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : nil
+        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : []
         if rest_start # XXX:squash
           ty = globalize_type(env.locals[lead_num + opt.size - 1], env, ep)
           rest_ty = Type.bot
@@ -1085,31 +1174,7 @@ module TypeProf
 
       when :definemethod
         mid, iseq = operands
-        cref = ep.ctx.cref
-        recv = env.static_env.recv_ty
-        if cref.klass.is_a?(Type::Class)
-          typed_mdef = check_typed_method(cref.klass, mid, ep.ctx.cref.singleton)
-          recv = Type::Instance.new(recv) if recv.is_a?(Type::Class)
-          if typed_mdef
-            mdef = ISeqMethodDef.new(iseq, cref)
-            typed_mdef.each do |typed_mdef|
-              typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
-            end
-          else
-            if ep.ctx.cref.singleton
-              meth = add_singleton_iseq_method(cref.klass, mid, iseq, cref)
-            else
-              meth = add_iseq_method(cref.klass, mid, iseq, cref)
-              if env.static_env.mod_func
-                add_singleton_iseq_method(cref.klass, mid, iseq, cref)
-              end
-            end
-
-            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref)
-          end
-        else
-          # XXX: what to do?
-        end
+        do_define_iseq_method(ep, env, mid, iseq, nil)
 
       when :definesmethod
         mid, iseq = operands
@@ -1117,8 +1182,8 @@ module TypeProf
         cref = ep.ctx.cref
         recv.each_child do |recv|
           if recv.is_a?(Type::Class)
-            meth = add_singleton_iseq_method(recv, mid, iseq, cref)
-            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref)
+            meth = add_singleton_iseq_method(recv, mid, iseq, cref, nil, env.static_env.pub_meth)
+            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, nil)
           else
             recv = Type.any # XXX: what to do?
           end
@@ -1154,10 +1219,11 @@ module TypeProf
             else # module
               superclass = nil
             end
-            if cbase == Type.any
-              klass = Type.any
-            else
+            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
+            else
+              klass = Type.any
             end
           end
           singleton = false
@@ -1179,7 +1245,7 @@ module TypeProf
         nctx = Context.new(iseq, ncref, nil)
         nep = ExecutionPoint.new(nctx, 0, nil)
         locals = [Type.nil] * iseq.locals.size
-        nenv = Env.new(StaticEnv.new(recv, blk, false), locals, [], Utils::HashWrapper.new({}))
+        nenv = Env.new(StaticEnv.new(recv, blk, false, true), locals, [], Utils::HashWrapper.new({}))
         merge_env(nep, nenv)
         add_callsite!(nep.ctx, ep, env) do |ret_ty, ep, env|
           nenv, ret_ty = localize_type(ret_ty, env, ep)
@@ -1245,30 +1311,30 @@ module TypeProf
         end
       when :invokesuper
         env, recv, _, aargs = setup_actual_arguments(:method, operands, ep, env)
-
-        env, recv = localize_type(env.static_env.recv_ty, env, ep)
-        mid  = ep.ctx.mid
-        singleton = !recv.is_a?(Type::Instance) # TODO: any?
-        # XXX: need to support included module...
-        meths = get_super_method(ep.ctx, singleton) # TODO: multiple return values
-        if meths
-          meths.each do |meth|
-            # 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)
+        mid = ep.ctx.mid
+        found = false
+        recv.each_child_global do |recv|
+          klass, singleton = recv.method_dispatch_info
+          next unless klass
+          get_all_super_methods(klass, singleton, ep.ctx.cref.klass, ep.ctx.mid) do |meths, klass|
+            found = true
+            meths.each do |meth|
+              # 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
               end
             end
           end
-          return
-        else
-          error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
-          env = env.push(Type.any)
         end
+        return if found
+        error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
+        env = env.push(Type.any)
       when :invokebuiltin
         raise NotImplementedError
       when :leave
@@ -1295,11 +1361,24 @@ module TypeProf
           return
         when :break
           tmp_ep = ep
-          tmp_ep = tmp_ep.outer while tmp_ep.ctx.iseq.type != :block
-          tmp_ep = tmp_ep.outer
-          nenv = @return_envs[tmp_ep].push(ty)
-          merge_env(tmp_ep.next, nenv)
-          # TODO: jump to ensure?
+          while true
+            if tmp_ep.ctx.iseq.type == :block
+              tmp_ep = tmp_ep.outer
+              nenv = @return_envs[tmp_ep].push(ty)
+              merge_env(tmp_ep.next, nenv)
+              break
+            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, = nenv.pop(nenv.stack.size - stack_depth)
+              nenv = nenv.push(ty)
+              tmp_ep = tmp_ep.jump(cont)
+              merge_env(tmp_ep, nenv)
+              break
+            end
+            tmp_ep = tmp_ep.outer
+          end
         when :next, :redo
           # begin; rescue; next; end
           tmp_ep = ep.outer
@@ -1492,9 +1571,7 @@ module TypeProf
         ret_ty.each_child do |ret_ty|
           flow_env = env.local_update(-var_idx+2, ret_ty)
           ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::Symbol)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalCell)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalArray)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalHash)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::Local)
           if ret_ty.is_a?(Type::Instance)
             if ret_ty.klass == pattern_ty # XXX: inheritance
               merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
@@ -1543,7 +1620,7 @@ module TypeProf
           warn(ep, "already initialized constant #{ Type::Instance.new(cbase).screen_name(self) }::#{ name }")
         end
         ty.each_child do |ty|
-          if ty.is_a?(Type::Class) && ty.superclass == Type::Builtin[:struct]
+          if ty.is_a?(Type::Class) && cbase.is_a?(Type::Class) && ty.superclass == Type::Builtin[:struct]
             @class_defs[ty.idx].name = cbase_path(cbase) + [name]
           end
         end
@@ -1552,7 +1629,6 @@ module TypeProf
       when :getspecial
         key, type = operands
         if type == 0
-          raise NotImplementedError
           case key
           when 0 # VM_SVAR_LASTLINE
             env = env.push(Type.any) # or String | NilClass only?
@@ -1570,8 +1646,12 @@ module TypeProf
           return
         end
       when :setspecial
-        # flip-flop
-        raise NotImplementedError, "setspecial"
+        key, = operands
+        if key >= 2 # flip-flop
+          env, = env.pop(1)
+        else
+          raise "unknown setspecial key: #{ key }"
+        end
 
       when :dup
         env, (ty,) = env.pop(1)
@@ -1622,10 +1702,16 @@ module TypeProf
         env = env.push(Type.optional(sym_ty))
       when :checkmatch
         flag, = operands
+
+        # This flag means that the stack top is an array, and the check needs to be applied to find all elements
+        # However, currently TypeProf uses very conservative interpretation (all check returns both true and false),
+        # so we just ignore the flag now
         _array = flag & 4 != 0
+
         case flag & 3
-        when 1
-          raise NotImplementedError
+        when 1 # VM_CHECKMATCH_TYPE_WHEN
+          env, = env.pop(2)
+          env = env.push(Type.bool)
         when 2 # VM_CHECKMATCH_TYPE_CASE
           env, = env.pop(2)
           env = env.push(Type.bool)
@@ -1660,9 +1746,13 @@ module TypeProf
         from_head = flag & 2 == 0
         ary.each_child do |ary|
           case ary
-          when Type::LocalArray
-            elems = get_container_elem_types(env, ep, ary.id)
-            elems ||= Type::Array::Elements.new([], Type.any) # XXX
+          when Type::Local
+            if ary.kind == Type::Array
+              elems = get_container_elem_types(env, ep, ary.id)
+              elems ||= Type::Array::Elements.new([], Type.any) # XXX
+            else
+              elems = Type::Array::Elements.new([], Type.any) # XXX
+            end
             do_expand_array(ep, env, elems, num, splat, from_head)
           when Type::Any
             nnum = num
@@ -1682,9 +1772,9 @@ module TypeProf
         return
       when :concatarray
         env, (ary1, ary2) = env.pop(2)
-        if ary1.is_a?(Type::LocalArray)
+        if ary1.is_a?(Type::Local) && ary1.kind == Type::Array
           elems1 = get_container_elem_types(env, ep, ary1.id)
-          if ary2.is_a?(Type::LocalArray)
+          if ary2.is_a?(Type::Local) && ary2.kind == Type::Array
             elems2 = get_container_elem_types(env, ep, ary2.id)
             elems = Type::Array::Elements.new([], elems1.squash.union(elems2.squash))
             env = update_container_elem_types(env, ep, ary1.id, ary1.base_type) { elems }
@@ -1831,6 +1921,10 @@ module TypeProf
         rest_ty = aargs.last
         aargs = aargs[0..-2]
         if flag_args_kw_splat
+          # XXX: The types contained in ActualArguments are expected to be all local types.
+          # This "globalize_type" breaks the invariant, and violates the assertion of Union#globalize that asserts @elems be nil.
+          # To fix this issue fundamentally, ActualArguments should keep all arguments as-is (as like the VM does),
+          # and globalize some types on the on-demand bases.
           ty = globalize_type(rest_ty, env, ep)
           if ty.is_a?(Type::Array)
             _, (ty,) = ty.elems.take_last(1)
@@ -1863,6 +1957,10 @@ module TypeProf
         aargs = ActualArguments.new(aargs, rest_ty, kw_tys, blk_ty)
       elsif flag_args_kw_splat
         last = aargs.last
+        # XXX: The types contained in ActualArguments are expected to be all local types.
+        # This "globalize_type" breaks the invariant, and violates the assertion of Union#globalize that asserts @elems be nil.
+        # To fix this issue fundamentally, ActualArguments should keep all arguments as-is (as like the VM does),
+        # and globalize some types on the on-demand bases.
         ty = globalize_type(last, env, ep)
         case ty
         when Type::Hash
@@ -1906,7 +2004,7 @@ module TypeProf
         nctx = Context.new(blk_iseq, ep.ctx.cref, ep.ctx.mid)
         nep = ExecutionPoint.new(nctx, 0, ep)
         nlocals = [Type.any] * blk_iseq.locals.size
-        nsenv = StaticEnv.new(env.static_env.recv_ty, Type.any, env.static_env.mod_func)
+        nsenv = StaticEnv.new(env.static_env.recv_ty, Type.any, env.static_env.mod_func, env.static_env.pub_meth)
         nenv = Env.new(nsenv, nlocals, [], nil)
         pend_block_dummy_execution(blk_ty, blk_iseq, nep, nenv)
         merge_return_env(ep) {|tenv| tenv ? tenv.merge(env) : env }
@@ -1916,20 +2014,31 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, ep, env, &ctn)
-      meths = recv.get_method(mid, self)
-      if meths
-        meths.each do |meth|
-          meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
-        end
+      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
-        case recv
-        when Type::Void
-          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-        when Type::Any
+        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
         else
-          error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+          meths = get_method(klass, singleton, :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
-        ctn[Type.any, ep, env]
       end
     end
 
@@ -1944,6 +2053,34 @@ module TypeProf
       end
     end
 
+    def do_define_iseq_method(ep, env, mid, iseq, outer_ep)
+      cref = ep.ctx.cref
+      if cref.klass.is_a?(Type::Class)
+        typed_mdef = check_typed_method(cref.klass, mid, ep.ctx.cref.singleton)
+        recv = cref.klass
+        recv = Type::Instance.new(recv) unless ep.ctx.cref.singleton
+        if typed_mdef
+          mdef = ISeqMethodDef.new(iseq, cref, outer_ep, env.static_env.pub_meth)
+          typed_mdef.each do |typed_mdef|
+            typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
+          end
+        else
+          if ep.ctx.cref.singleton
+            meth = add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep, true)
+          else
+            meth = add_iseq_method(cref.klass, mid, iseq, cref, outer_ep, env.static_env.pub_meth)
+            if env.static_env.mod_func
+              add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep, true)
+            end
+          end
+        end
+
+        pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
+      else
+        # XXX: what to do?
+      end
+    end
+
     def show_block_signature(blks)
       bsig = nil
       ret_ty = Type.bot
@@ -1984,7 +2121,7 @@ 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(@method_signatures[blk_ctx])
+              farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
             else
               farg_tys = @method_signatures[blk_ctx]
             end