typeprof 0.7.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8ecd99e5448a244b11714710dfbb5fd3f36274c5f72fa97da034059018fc32f
-  data.tar.gz: ed322065cf15d08f7bb50105cce19d74d923d4d7af7f94a563668788849d636d
+  metadata.gz: 8d68099e4f5d60a45f949d6bfc3a47e8b7d3b7ba66a0794f25f5fe61628de1d1
+  data.tar.gz: 22792d1acb9b16a4150f1afbaf29d59987bf29772908b23075e6668df81a4309
 SHA512:
-  metadata.gz: 528dcf83aa2ceec79ea602f3505eb48230baf87bae8409212f8f152b45e308c66490ff5d10a9153698870e02b0ee5f031ce81cbb48a4460187992269708957ef
-  data.tar.gz: a03594cb0b6a88ba905dc860ba9de64beb82a6cb1ebc562aad94cf20ecf14e36534bbf8a29a0b629189c62c32c26437104acb4387159c17bb222c708614cc303
+  metadata.gz: 42faa4e3b5c64fd5976e66067bf13339c530785914caad77bc0a405939bc914e9adf78bfbd0aea57a829cb21aed3c6dfc09f8f57def85b09312facd82d33b5a9
+  data.tar.gz: bc6f115fbf1d5292286f04f09d745cfb0c13688a71fdae730d0cfdd903ad8f9f3f9019e532c37b4cf23fe41f39c9a1683f92f28af68716ddf7e625a0efca33f8

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.7.0)
-      rbs (>= 0.17.0)
+    typeprof (0.10.0)
+      rbs (>= 0.20.1)
 
 GEM
   remote: https://rubygems.org/
@@ -11,17 +11,20 @@ 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.7)
       power_assert
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   coverage-helpers
@@ -33,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.2.0.rc.1
+   2.2.1

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
 
@@ -195,12 +208,22 @@ module TypeProf
     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
+
+    def replace_blk_ty(ty)
+      senv = StaticEnv.new(@static_env.recv_ty, ty, @static_env.mod_func, @static_env.pub_meth)
       Env.new(senv, @locals, @stack, @type_params)
     end
 
@@ -277,7 +300,10 @@ module TypeProf
       def initialize(kind, name, absolute_path)
         raise unless name.is_a?(Array)
         @kind = kind
-        @modules = { true => [], false => [] }
+        @modules = {
+          :before => { true => [], false => [] }, # before = include/extend
+          :after  => { true => [], false => [] }, # after = prepend
+        }
         @name = name
         @consts = {}
         @methods = {}
@@ -290,13 +316,13 @@ module TypeProf
       attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       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
-          raise "inconsistent include/extend type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
+      def mix_module(kind, mod, type_args, singleton, absolute_path)
+        mod_, module_type_args, absolute_paths = @modules[kind][singleton].find {|m,| m == mod }
+        if mod_
+          raise "inconsistent #{ kind == :after ? "include/extend" : "prepend" } 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])
+          @modules[kind][singleton].unshift([mod, type_args, absolute_paths])
         end
         absolute_paths << absolute_path
       end
@@ -313,10 +339,8 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      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,|
+      def adjust_substitution_for_module(mods, mid, mthd, subst, &blk)
+        mods.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|
@@ -328,11 +352,29 @@ module TypeProf
         end
       end
 
-      def search_method(singleton, mid, &blk)
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+        adjust_substitution_for_module(@modules[:before][singleton], mid, mthd, subst, &blk)
+
+        mthds = @methods[[singleton, mid]]
+        yield subst, direct if mthds&.include?(mthd)
+
+        adjust_substitution_for_module(@modules[:after][singleton], mid, mthd, subst, &blk)
+      end
+
+      def search_method(singleton, mid, visited, &blk)
+        # Currently, circular inclusion of modules is allowed
+        return if visited[self]
+        visited[self] = true
+
+        @modules[:before][singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, visited, &blk)
+        end
+
         mthds = @methods[[singleton, mid]]
         yield mthds, @klass_obj, singleton if mthds
-        @modules[singleton].each do |mod_def,|
-          mod_def.search_method(false, mid, &blk)
+
+        @modules[:after][singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, visited, &blk)
         end
       end
 
@@ -360,17 +402,17 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, type_args, singleton, absolute_path)
-      return if included_mod == Type.any
+    def mix_module(kind, mixing_mod, mixed_mod, type_args, singleton, caller_ep)
+      return if mixed_mod == Type.any
 
-      including_mod = @class_defs[including_mod.idx]
-      included_mod.each_child do |included_mod|
-        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)
+      mixing_mod = @class_defs[mixing_mod.idx]
+      mixed_mod.each_child do |mixed_mod|
+        if mixed_mod.is_a?(Type::Class)
+          mixed_mod = @class_defs[mixed_mod.idx]
+          if mixed_mod && mixed_mod.kind == :module
+            mixing_mod.mix_module(kind, mixed_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, "attempted to #{ kind == :after ? "include/extend" : "prepend" } non-module; ignored")
           end
         end
       end
@@ -380,12 +422,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)
@@ -393,13 +435,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]
 
@@ -407,7 +453,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, [Type.any], 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
@@ -467,13 +514,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)
@@ -533,9 +580,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
@@ -554,39 +599,39 @@ module TypeProf
       mdef
     end
 
-    def add_attr_method(klass, absolute_path, mid, ivar, kind)
+    def add_attr_method(klass, mid, ivar, kind, pub_meth, ep)
       if kind == :reader || kind == :accessor
-        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, absolute_path))
+        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, pub_meth, ep))
       end
       if kind == :writer || kind == :accessor
-        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, absolute_path))
+        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, pub_meth, ep))
       end
     end
 
-    def add_iseq_method(klass, mid, iseq, cref, outer_ep)
-      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref, outer_ep))
+    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, outer_ep)
-      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref, outer_ep))
+    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)
-      set_method(klass, mid, false, CustomMethodDef.new(impl))
+    def set_custom_method(klass, mid, impl, pub_meth = true)
+      set_method(klass, mid, false, CustomMethodDef.new(impl, pub_meth))
     end
 
-    def set_singleton_custom_method(klass, mid, impl)
-      set_method(klass, mid, true, CustomMethodDef.new(impl))
+    def set_singleton_custom_method(klass, mid, impl, pub_meth = true)
+      set_method(klass, mid, true, CustomMethodDef.new(impl, pub_meth))
     end
 
-    def alias_method(klass, singleton, new, old)
+    def alias_method(klass, singleton, alias_mid, orig_mid, ep)
       if klass == Type.any
         self
       else
-        mdefs = get_method(klass, singleton, old)
+        mdefs = get_method(klass, singleton, orig_mid)
         if mdefs
           mdefs.each do |mdef|
-            @class_defs[klass.idx].add_method(new, singleton, mdef)
+            @class_defs[klass.idx].add_method(alias_mid, singleton, AliasMethodDef.new(orig_mid, mdef, ep))
           end
         end
       end
@@ -601,6 +646,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)
 
@@ -660,8 +709,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)
@@ -669,7 +720,7 @@ module TypeProf
         if ep
           if entry.rbs_declared
             unless Type.match?(ty, entry.type)
-              scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
+              scratch.warn(ep, "inconsistent assignment to RBS-declared variable")
               return
             end
           end
@@ -719,6 +770,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)
@@ -727,6 +779,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)
@@ -858,7 +911,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
@@ -953,7 +1006,7 @@ 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({}))
 
       if !@pending_execution[iseq] || @pending_execution[iseq][0] == :block
         @pending_execution[iseq] = [:method, [meth, ep, env]]
@@ -962,10 +1015,14 @@ module TypeProf
 
     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
 
@@ -1014,9 +1071,9 @@ 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)
+          ty = globalize_type(env.locals[rest_start], env, ep)
           rest_ty = Type.bot
           ty.each_child_global do |ty|
             if ty.is_a?(Type::Array)
@@ -1051,6 +1108,7 @@ module TypeProf
           end
         end
         kw_rest_ty = globalize_type(env.locals[kw_rest], env, ep) if kw_rest
+        kw_rest_ty = nil if kw_rest_ty == Type.nil
         if block_start
           blk_ty = globalize_type(env.locals[block_start], env, ep)
         elsif iseq.type == :method
@@ -1148,7 +1206,7 @@ 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, nil)
+            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?
@@ -1185,11 +1243,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
@@ -1211,7 +1269,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)
@@ -1230,7 +1288,7 @@ module TypeProf
           end
         end
         return
-      when :send_branch
+      when :getlocal_send_branch
         getlocal_operands, send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
@@ -1258,6 +1316,31 @@ module TypeProf
           end
         end
         return
+      when :send_branch
+        send_operands, branch_operands = operands
+        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
+        recvs = Type.any if recvs == Type.bot
+        recvs.each_child do |recv|
+          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
+            env, ret_ty, = localize_type(ret_ty, env, ep)
+
+            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
+          end
+        end
+        return
       when :invokeblock
         env, recvs, mid, aargs = setup_actual_arguments(:block, operands, ep, env)
         blk = env.static_env.blk_ty
@@ -1327,11 +1410,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
@@ -1573,7 +1669,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
@@ -1582,7 +1678,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?
@@ -1600,8 +1695,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)
@@ -1652,10 +1751,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)
@@ -1865,6 +1970,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)
@@ -1897,6 +2006,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
@@ -1940,7 +2053,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 }
@@ -1991,27 +2104,27 @@ module TypeProf
 
     def do_define_iseq_method(ep, env, mid, iseq, outer_ep)
       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)
+        recv = cref.klass
+        recv = Type::Instance.new(recv) unless ep.ctx.cref.singleton
         if typed_mdef
-          mdef = ISeqMethodDef.new(iseq, cref, outer_ep)
+          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)
+            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)
+            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)
+              add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep, true)
             end
           end
-
-          pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
         end
+
+        pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
       else
         # XXX: what to do?
       end
@@ -2040,7 +2153,7 @@ module TypeProf
 
       bsig ||= BlockSignature.new([], [], nil, Type.nil)
 
-      bsig = bsig.screen_name(self)#, block: true)
+      bsig = bsig.screen_name(nil, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
@@ -2057,7 +2170,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
@@ -2067,7 +2180,7 @@ module TypeProf
         end
       end
 
-      farg_tys = farg_tys ? farg_tys.screen_name(self) : "(unknown)"
+      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?
 
@@ -2079,7 +2192,7 @@ module TypeProf
       farg_tys = @method_signatures[ctx]
       ret_ty = @return_values[ctx] || Type.bot
 
-      farg_tys = farg_tys.screen_name(self)
+      farg_tys = farg_tys.screen_name(ctx.iseq, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
       "#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }"