typeprof 0.6.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '080db9120b2b069f8a1385e3696851212a2271652f73b8627d5337d2d26d8f2b'
-  data.tar.gz: 969e38b2a1b64ec3fbe90551b440418901c8af028c7126b1f56acaca3818d2b1
+  metadata.gz: 481ba91ab18504fff44772720b462a9fa302e4eecddb559c3a5942710e081fa9
+  data.tar.gz: 288ddfd1d6c9e198ea62e6564addf40ce851c91337801db44f2957c98b9f58f5
 SHA512:
-  metadata.gz: 322bff1d2a49e9a2729012064e393138cb9e4b81472e1c75b14a2d55a4fe3616ef3efc5ecf5df3a156a418ff6ad0281c24c2c585c61a733db0c6e4d05ceb6595
-  data.tar.gz: 78de3b56104b239c272938a9877bfdd49ccf20df8dbd360bf5fe7ef3c342e1d746c2adbf957fd511c03156258effe630c440941e600d58b7e7cd914ff11ca4d5
+  metadata.gz: 7f1eefdf5e92e2fa79a03979e36dd810ffcb337c426035acc384473e45fe6201487e8354608b4b87582515561b214e3ef339edd19e3980fab2873e6bc24cb9c5
+  data.tar.gz: cd74500c47328634ab7991911f795e7ea9b5cc47c15e3540c7796b39c2d1d83661cd50b45623e92cf1f33cbf1e83c4c8b5796a5e5332c8e1f475d3f1d26c043c

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.6.0)
-      rbs (>= 0.17.0)
+    typeprof (0.9.1)
+      rbs (>= 0.20.1)
 
 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
 
@@ -298,8 +309,8 @@ module TypeProf
       attr_accessor :name, :klass_obj
 
       def include_module(mod, type_args, singleton, absolute_path)
-        module_type_args, _, absolute_paths = @modules[singleton].find {|m,| m == mod }
-        if module_type_args
+        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
@@ -320,9 +331,9 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def generate_substitution(singleton, mid, mthd, subst, &blk)
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
         mthds = @methods[[singleton, mid]]
-        yield subst if mthds&.include?(mthd)
+        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 = {}
@@ -330,16 +341,19 @@ module TypeProf
               tyvar = Type::Var.new(tyvar)
               subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
             end
-            mod_def.generate_substitution(false, mid, mthd, subst2, &blk)
+            mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
           end
         end
       end
 
-      def search_method(singleton, mid, &blk)
+      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, &blk)
+          mod_def.search_method(false, mid, visited, &blk)
         end
       end
 
@@ -358,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, type_args, 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]
@@ -371,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, type_args, 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
@@ -383,12 +401,12 @@ module TypeProf
       cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
     end
 
-    def new_class(cbase, name, type_params, superclass, superclass_type_args, absolute_path)
+    def new_class(cbase, name, type_params, superclass, absolute_path)
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
         @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
-        klass = Type::Class.new(:class, idx, type_params, superclass, superclass_type_args, show_name)
+        klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
         add_constant(cbase, name, klass, absolute_path)
@@ -396,13 +414,17 @@ module TypeProf
       else
         # module
         @class_defs[idx] = ClassDef.new(:module, show_name, absolute_path)
-        mod = Type::Class.new(:module, idx, type_params, nil, nil, show_name)
+        mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
         add_constant(cbase, name, mod, absolute_path)
         return mod
       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]
 
@@ -410,7 +432,8 @@ 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)
-      klass = Type::Class.new(:class, idx, [], superclass, [], name)
+      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
@@ -440,11 +463,13 @@ module TypeProf
       end
     end
 
-    def generate_substitution(klass, singleton, mid, mthd, subst, &blk)
+    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.generate_substitution(singleton, mid, mthd, subst, &blk)
+          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|
@@ -458,7 +483,7 @@ module TypeProf
       else
         # module
         class_def = @class_defs[klass.idx]
-        class_def.generate_substitution(singleton, mid, mthd, subst, &blk)
+        class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
       end
     end
 
@@ -468,13 +493,13 @@ module TypeProf
       if klass.kind == :class
         while klass != :__root__
           class_def = @class_defs[klass.idx]
-          class_def.search_method(singleton, mid, &blk)
+          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)
+        class_def.search_method(singleton, mid, {}, &blk)
       end
       if singleton
         search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
@@ -534,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
@@ -564,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)
@@ -602,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)
 
@@ -661,8 +688,10 @@ 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
-        ctn[entry.type, ep]
+        entry.absolute_paths << ep.ctx.iseq.absolute_path if ep.ctx.is_a?(Context)
+        ty = entry.type
+        ty = Type.nil if ty == Type.bot
+        ctn[ty, ep]
       end
 
       def add_write!(site, ty, ep, scratch)
@@ -720,6 +749,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)
@@ -728,6 +758,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)
@@ -778,7 +809,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)
@@ -790,7 +821,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)
@@ -831,11 +862,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
@@ -851,9 +882,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
@@ -861,7 +890,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
@@ -878,7 +907,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
@@ -919,9 +948,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
@@ -956,17 +985,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
 
@@ -975,7 +1010,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
@@ -1015,7 +1050,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
@@ -1141,31 +1176,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
@@ -1173,8 +1184,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
@@ -1210,11 +1221,11 @@ module TypeProf
             else # module
               superclass = nil
             end
-            if cbase == Type.any
-              klass = Type.any
+            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
-              superclass_type_args = superclass.type_params.map { Type.any } if superclass
-              klass = new_class(cbase, id, [], superclass, superclass_type_args, ep.ctx.iseq.absolute_path)
+              klass = Type.any
             end
           end
           singleton = false
@@ -1236,7 +1247,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)
@@ -1352,11 +1363,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
@@ -1549,9 +1573,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)
@@ -1600,7 +1622,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
@@ -1609,7 +1631,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?
@@ -1627,8 +1648,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)
@@ -1679,10 +1704,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)
@@ -1717,9 +1748,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
@@ -1739,9 +1774,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 }
@@ -1888,6 +1923,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)
@@ -1920,6 +1959,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
@@ -1963,7 +2006,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 }
@@ -1973,21 +2016,31 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, ep, env, &ctn)
-      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
+      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
 
@@ -2002,6 +2055,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
@@ -2042,7 +2123,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