typeprof 0.8.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd38b5e501a5d4fbe4db1ad43015c44ab39dbfefc3f7638516faeb5bcafd21a9
-  data.tar.gz: 000f140ab750e4ddd57863851c21a830bfe470c0eb7be9e38442ca535f4ef041
+  metadata.gz: 88521dfb48f311cdb5b651e88afc2627a28040a466a22b50303415531e663cfd
+  data.tar.gz: 4bd17f9d016d6e7a60ed72804eb050a5611af0869275e63d3486700a53befaaf
 SHA512:
-  metadata.gz: '00924963d5f91c4609224615507fcfb240a140c8119bf76f24aa28973342e6b61c528fc579781690f9f0392bf0d125c8bdb70499525791603c111ed9251da931'
-  data.tar.gz: ee07e0636cd3e26271c468e1927e676a1b320ddefe13dc2412c254cac9aaeac7ca5db1936a26ccc477c2494473fde1d2bdde7a28bd1fa384c6995d7ae4d085ea
+  metadata.gz: f88b069345f02729a09c0516baf4ff31c8aef640adf5a2c53f62f72a9fb8b96b4309993ae79e37ece4ec33972f762005b3898ca7c894cda65c3727513b812b6b
+  data.tar.gz: aa5fec1acd9dd6395d3d16e044f08e7b72fac0f41dc6168683c631fcadca33daf2415b9956ba00cd22c573c6732719fad9eeef3d601a16943d59be6986703c20

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    typeprof (0.8.0)
-      rbs (>= 0.17.0)
+    typeprof (0.11.0)
+      rbs (>= 1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coverage-helpers (1.0.0)
-    docile (1.3.2)
+    docile (1.3.4)
     power_assert (1.2.0)
     rake (13.0.1)
-    rbs (0.18.1)
+    rbs (1.0.0)
     simplecov (0.20.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -24,6 +24,7 @@ GEM
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   coverage-helpers
@@ -35,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.2.0.rc.1
+   2.2.3

data/doc/demo.md

@@ -39,7 +39,7 @@ class Object
 end
 ```
 
-Yoy can [try this analysis online](https://mame.github.io/typeprof-playground/#rb=def+hello_message%28user%29%0A++%22The+name+is+%22+%2B+user.name%0Aend%0A%0Adef+type_error_demo%28user%29%0A++%22The+age+is+%22+%2B+user.age%0Aend%0A%0Auser+%3D+User.new%28name%3A+%22John%22%2C+age%3A+20%29%0A%0Ahello_message%28user%29%0Atype_error_demo%28user%29&rbs=class+User%0A++attr_reader+name%3A+String%0A++attr_reader+age%3A+Integer%0A%0A++def+initialize%3A+%28name%3A+String%2C+age%3A+Integer%29+-%3E+void%0Aend).
+You can [try this analysis online](https://mame.github.io/typeprof-playground/#rb=def+hello_message%28user%29%0A++%22The+name+is+%22+%2B+user.name%0Aend%0A%0Adef+type_error_demo%28user%29%0A++%22The+age+is+%22+%2B+user.age%0Aend%0A%0Auser+%3D+User.new%28name%3A+%22John%22%2C+age%3A+20%29%0A%0Ahello_message%28user%29%0Atype_error_demo%28user%29&rbs=class+User%0A++attr_reader+name%3A+String%0A++attr_reader+age%3A+Integer%0A%0A++def+initialize%3A+%28name%3A+String%2C+age%3A+Integer%29+-%3E+void%0Aend).
 
 ## A simple demo to generate the signature prototype of "User" class
 

data/doc/todo.md

@@ -0,0 +1,133 @@
+# TypeProf milestones and TODOs
+
+## Big milestones
+
+### Rails support
+
+There are many known issues for the analysis of typical Ruby programs including Rails apps.
+
+* The main difficulty is that they use many language extensions like `ActiveSupport`.
+  Some features (for example, `blank?` and `Time.now + 1.day`) are trivial to support,
+  but others (for example, `ActiveSupport::Concern` and Zeitwerk) will require special support.
+* The other difficulty is that they heavily use meta-programming features like `ActiveRecord`.
+  It dynamically defines some methods based on external data (such as DB schema) from the code.
+
+Currently, projects called [`gem_rbs`](https://github.com/ruby/gem_rbs) and [`rbs_rails`](https://github.com/pocke/rbs_rails) are in progress.
+The former provides several RBS files for some major gems including Rails.
+The latter is a tool to generate RBS prototype of a target Rails application by introspection (executing it and monitoring DB schema, etc).
+TypeProf can use their results to improve analysis precision and performance.
+
+What we need to do:
+
+* Experimentally apply TypeProf to some Rails programs and identify problems
+* Make TypeProf able to work together with `rbs_rails` for supporting trivial core extensions and `ActiveRecord`.
+* Implement special support for some fundamental language extensions of Rails like `ActiveSupport::Concern`.
+  (It would be best if TypeProf has a plugin system and if we can factor out the special support as a plugin for Rails.)
+
+### Error detection and diagnosis feature
+
+At present, TypeProf focuses on generation of RBS prototype from no-type-annotated Ruby code.
+However, it is possible for TypeProf to report possible errors found during the analysis.
+In fact, an option `-v` experimentally shows possible errors found.
+There are some reasons why it is disabled by default:
+
+* (1) There are too many false positives.
+* (2) Some kind of error reporting is not implemented yet.
+* (3) Some reported errors are difficult for a user to understand.
+
+For (1), we will research how we can avoid false positives to support typical Ruby coding patterns as much as possible.
+The primary way is to improve the analysis precision, e.g., enhancing flow-sensitive analysis.
+If the S/N ratio of an error type is too low, we need to consider to suppress the kind of reports.
+Also, we may try allowing users to guide TypeProf to analyze their program well.
+(The simplest way is to write inline type casts in the code, but we need to find more Ruby/RBS way.)
+We may also explore a "TypeProf-friendly coding style" which TypeProf can analyze well.
+(In principle, the plainer code is, the better TypeProf can analyze.)
+
+For (2), currently, TypeProf checks the argument types of a call to a method whose type signature is declared in RBS.
+However, it does not check the return type yet. Redefinition of constants should be warned too.
+We will survey what errors and warnings TypeProf can print, and evaluate the S/N ratio of each report.
+
+For (3), since TypeProf uses whole program analysis, an error may be reported at a very different place from its root bug.
+Thus, if TypeProf shows a possible type error, a diagnosis feature is needed to answer why TypeProf thinks that the error may occur.
+TypeProf has already implemented a very primitive diagnosis feature, `Kernel#p`, to check what type an expression has.
+Another idea is to create a pseudo backtrace why TypeProf thought the possible type error may occur.
+We should consider this feature with LSP support.
+
+### Performance improvement
+
+Currently, TypeProf is painfully slow. Even if a target application is small.
+
+The main reason is that TypeProf analyzes not only the application code but also library code:
+if an application requires `"foo"`, TypeProf actually loads `foo.rb` even from a gem,
+and furthermore, if `foo.rb` requires `"bar"`, it loads `bar.rb` recursively.
+
+RBS will help to stop this cascade;
+when an application requires `"foo"`, TypeProf loads `sig/foo.rbs` instead of `foo.rb` if the `foo` gem contains both.
+Such a RBS file is optional for TypeProf but required for Steep.
+So, we think many gems will eventually equip their RBS declarations.
+
+That being said, we should continue to improve the analysis performance of TypeProf. We have some ideas.
+
+* Unfortunately, TypeProf often analyzes one method more than once when it accepts multiple types.
+  As TypeProf squashes the argument types to a union, this duplicated analysis is not necessarily needed.
+  But when TypeProf first analyzes a method, it is difficult to determine if the method will accept another type in further analysis.
+  So, we need good heuristics to guess whether a method accepts multiple types or not, and if so, delay its analysis.
+* Currently, TypeProf executes the bytecode instructions step by step.
+  This requires creating an environment object after each instruction, which is very heavy.
+  Many environment creations can be omitted by executing each basic block instead of each instruction.
+  (Basic block execution will also make flow-sensitive analysis easier.)
+* The slowest calculation in TypeProf is to create an instance of a Type class.
+  The creation uses memoization; TypeProf keeps all Type instances created so far, and reuses them if already exist.
+  However, it is very heavy to check if an instance already exists or not.
+  (Currently, it is very simply implemented by a big Hash table.)
+  We've already improved the memoization routine several times but looks like it is still the No.1 bottleneck.
+  We need to investigate and try improving more.
+* TypeProf heavily uses Hash objects (including above) mainly to represent a set.
+  A union of sets is done by `Hash#merge`, which takes O(n).
+  A more lightweight data structure may make TypeProf faster.
+  (But clever structure often has a big constant term, so we need to evaluate the performance carefully.)
+* Reusing an old analysis and incrementally updating it will bring a super big improvement.
+  This would be especially helpful for LSP support, so we need to tackle it after the analysis approach is mature.
+
+### Language Server Protocol (LSP) support
+
+In the future, we want TypeProf to serve as a language server to show the result in IDE in real-time.
+However, the current analysis approach is too slow for IDE. So we need to improve the performance first.
+
+Even if TypeProf becomes fast enough, its approach has a fundamental problem.
+Since TypeProf uses whole program analysis, one edit may cause a cascade of propagation:
+if a user write `foo(42)`, an Integer is propagated to a method `foo`,
+and if `foo` passes its argument to a method `bar`, it is propagated to `bar`, ...
+So, a breakthrough for LSP may be still needed, e.g, limiting the propagation range in real-time analysis,
+assuming that a type interface of module boundary is fixed, etc.
+
+## Relatively smaller TODOs
+
+* Support more RBS features
+  * TypeProf does not deal with some RBS types well yet.
+    * For example, the `instance` type is handled as `untyped.
+    * The `self` type is handled well only when it is used as a return type.
+    * Using a value of the `void` type should be warned appropriately.
+  * RBS's `interface` is supported just like a module (i.e., `include _Foo` is explicitly required in RBS),
+    but it should be checked structually (i.e., it should be determined as a method set.)
+  * The variance of type parameters is currently ignored.
+
+* Support more Ruby features
+  * Some meta-programming features like `Class.new`, `Object#method`, etc.
+    * It is possible to support `Class.new` by per-allocation-site approach:
+      e.g., In TypeProf, `A = Class.new; B = Class.new` will create two classes, but `2.times { Class.new }` will create one class.
+  * The analysis precision can be improved more for some Ruby features like pattern matching, keyword arguments, etc.
+    * For example, `foo(*args, k:1)` is currently compiled as if it is `foo(*(args + [{ :k => 1 }]))` into Ruby bytecode.
+      This mixes the keyword arguments to a rest array, and makes it difficult for TypeProf to track the keyword arguments.
+  * Support Enumerator as an Array-type container.
+  * Support `Module#protect` (but RBS does not yet).
+  * More heuristics may help such as `==` returns a bool regardless to its receiver and argument types.
+
+* Make TypeProf more useful as a tool
+  * Currently, TypeProf provides only the analysis engine and a minimal set of features.
+  * The analysis result would be useful not only to generate RBS prototype
+    but also identifying the source location of a method definition, listing callsites of a method,
+    searching a method call by its argument types, etc.
+  * Sometimes, TypeProf prints very big union type, such as `Integer | Float | Complex | Rational | ...`.
+    Worse, the same big type is printed multiple times.
+    It may be useful to factor out such a long type by using type alias, for example.

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,12 +87,7 @@ module TypeProf
     end
 
     def source_location
-      iseq = @ctx.iseq
-      if iseq
-        iseq.source_location(@pc)
-      else
-        "<builtin>"
-      end
+      @ctx.source_location(@pc)
     end
   end
 
@@ -91,7 +102,7 @@ module TypeProf
 
       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
 
@@ -211,6 +222,11 @@ module TypeProf
       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
+
     def inspect
       "Env[#{ @static_env.inspect }, locals:#{ @locals.inspect }, stack:#{ @stack.inspect }, type_params:#{ (@type_params&.internal_hash).inspect }]"
     end
@@ -284,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 = {}
@@ -297,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
@@ -320,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|
@@ -335,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
 
@@ -367,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
@@ -479,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)
@@ -545,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
@@ -566,12 +599,12 @@ 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
 
@@ -583,22 +616,22 @@ module TypeProf
       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
@@ -613,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)
 
@@ -672,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)
@@ -681,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
@@ -731,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)
@@ -739,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)
@@ -870,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
@@ -974,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
 
@@ -1026,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)
@@ -1063,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
@@ -1197,11 +1243,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
@@ -1242,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
@@ -1270,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
@@ -1339,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
@@ -1585,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
@@ -1594,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?
@@ -1612,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)
@@ -1664,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)
@@ -1877,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)
@@ -1909,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
@@ -2003,10 +2104,10 @@ 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, env.static_env.pub_meth)
           typed_mdef.each do |typed_mdef|
@@ -2021,9 +2122,9 @@ module TypeProf
               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
@@ -2052,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?
 
@@ -2069,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
@@ -2079,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?
 
@@ -2091,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 }"