typeprof 0.5.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1281ceb7a6a28b6dec33aad740d0fa52429a17ca29d57747717247fdb449c79
-  data.tar.gz: 3ad79ab67ba6080e0c1da2b46671012e4db2f886020a11772158449ffd85717b
+  metadata.gz: dd38b5e501a5d4fbe4db1ad43015c44ab39dbfefc3f7638516faeb5bcafd21a9
+  data.tar.gz: 000f140ab750e4ddd57863851c21a830bfe470c0eb7be9e38442ca535f4ef041
 SHA512:
-  metadata.gz: c0e888c0c1cc871b23592f29d138f7c9c8ca5370fa98699c9b504aa29c79796f58d97653fac98cef2df1d8e7f5c961942ee28d385a95695e4ce7f1ff3c8d24f5
-  data.tar.gz: 3ee4de72a8e26aed401b1879575ef82c0b1215fe9ccb87ee2c781a8138becc9ab948aea00e07e8e344ca4f96610ebfefdc540f175253cfe32dca1f721c232e7f
+  metadata.gz: '00924963d5f91c4609224615507fcfb240a140c8119bf76f24aa28973342e6b61c528fc579781690f9f0392bf0d125c8bdb70499525791603c111ed9251da931'
+  data.tar.gz: ee07e0636cd3e26271c468e1927e676a1b320ddefe13dc2412c254cac9aaeac7ca5db1936a26ccc477c2494473fde1d2bdde7a28bd1fa384c6995d7ae4d085ea

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.5.2)
+    typeprof (0.8.0)
       rbs (>= 0.17.0)
 
 GEM
@@ -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.18.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

@@ -83,10 +83,11 @@ module TypeProf
   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|
@@ -94,13 +95,14 @@ module TypeProf
       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 +187,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
 
@@ -252,6 +252,8 @@ module TypeProf
       @rbs_reader = RBSReader.new
 
       @terminated = false
+
+      @anonymous_struct_gen_id = 0
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -279,11 +281,10 @@ module TypeProf
     attr_reader :class_defs
 
     class ClassDef # or ModuleDef
-      def initialize(kind, name, superclass, absolute_path)
+      def initialize(kind, name, absolute_path)
         raise unless name.is_a?(Array)
         @kind = kind
-        @superclass = superclass
-        @modules = { true => {}, false => {} }
+        @modules = { true => [], false => [] }
         @name = name
         @consts = {}
         @methods = {}
@@ -293,14 +294,16 @@ module TypeProf
         @namespace = nil
       end
 
-      attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, singleton, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[singleton][mod]
-        unless absolute_paths
-          @modules[singleton][mod] = absolute_paths = Utils::MutableSet.new
+      def include_module(mod, type_args, singleton, absolute_path)
+        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
+        else
+          absolute_paths = Utils::MutableSet.new
+          @modules[singleton].unshift([mod, type_args, absolute_paths])
         end
         absolute_paths << absolute_path
       end
@@ -317,13 +320,26 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def get_method(mid, singleton)
-        @methods[[singleton, mid]] || begin
-          @modules[singleton].each_key do |mod|
-            meth = mod.get_method(mid, false)
-            return meth if meth
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+        mthds = @methods[[singleton, mid]]
+        yield subst, direct if mthds&.include?(mthd)
+        @modules[singleton].each do |mod_def, type_args,|
+          if mod_def.klass_obj.type_params && type_args
+            subst2 = {}
+            mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
           end
-          nil
+        end
+      end
+
+      def search_method(singleton, mid, &blk)
+        mthds = @methods[[singleton, mid]]
+        yield mthds, @klass_obj, singleton if mthds
+        @modules[singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, &blk)
         end
       end
 
@@ -342,12 +358,16 @@ module TypeProf
       end
 
       def set_method(mid, singleton, mdef)
-        @methods[[singleton, mid]] = Utils::MutableSet.new
-        @methods[[singleton, mid]] << mdef
+        if mdef
+          @methods[[singleton, mid]] = Utils::MutableSet.new
+          @methods[[singleton, mid]] << mdef
+        else
+          @methods.delete([singleton, mid])
+        end
       end
     end
 
-    def include_module(including_mod, included_mod, singleton, absolute_path)
+    def include_module(including_mod, included_mod, type_args, singleton, absolute_path)
       return if included_mod == Type.any
 
       including_mod = @class_defs[including_mod.idx]
@@ -355,7 +375,7 @@ module TypeProf
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, singleton, absolute_path)
+            including_mod.include_module(included_mod, type_args, singleton, absolute_path)
           else
             warn "including something that is not a module"
           end
@@ -371,12 +391,7 @@ module TypeProf
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
-        if superclass == :__root__
-          superclass_idx = superclass = nil
-        else
-          superclass_idx = superclass.idx
-        end
-        @class_defs[idx] = ClassDef.new(:class, show_name, superclass_idx, absolute_path)
+        @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
@@ -384,7 +399,7 @@ module TypeProf
         return klass
       else
         # module
-        @class_defs[idx] = ClassDef.new(:module, show_name, nil, absolute_path)
+        @class_defs[idx] = ClassDef.new(:module, show_name, absolute_path)
         mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
         add_constant(cbase, name, mod, absolute_path)
@@ -392,13 +407,19 @@ module TypeProf
       end
     end
 
+    def add_superclass_type_args!(klass, tyargs)
+      klass.superclass_type_args = tyargs
+    end
+
     def new_struct(ep)
       return @struct_defs[ep] if @struct_defs[ep]
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
-      @class_defs[idx] = ClassDef.new(:class, ["(Anonymous Struct)"], superclass.idx, ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, "(Anonymous 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)
+      add_superclass_type_args!(klass, [Type.any])
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -428,28 +449,77 @@ module TypeProf
       end
     end
 
+    def adjust_substitution(klass, singleton, mid, mthd, subst, &blk)
+      direct = true
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+          direct = false
+          if klass.superclass && klass.superclass_type_args
+            subst2 = {}
+            klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            subst = subst2
+          end
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+      end
+    end
+
+    def search_method(klass, singleton, mid, &blk)
+      # XXX: support method alias correctly
+      klass_orig = klass
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.search_method(singleton, mid, &blk)
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.search_method(singleton, mid, &blk)
+      end
+      if singleton
+        search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
+      end
+    end
+
     def get_method(klass, singleton, mid)
-      idx = klass.idx
-      while idx
-        class_def = @class_defs[idx]
-        mthd = class_def.get_method(mid, singleton)
-        # Need to be conservative to include all super candidates...?
-        return mthd if mthd
-        idx = class_def.superclass
+      search_method(klass, singleton, mid) {|mthds,| return mthds }
+    end
+
+    def get_all_super_methods(klass, singleton, current_klass, mid)
+      hit = false
+      search_method(klass, singleton, mid) do |mthds, klass0, singleton0|
+        yield mthds, klass0, singleton0 if hit
+        hit = klass0 == current_klass
       end
-      return get_method(Type::Builtin[:class], false, mid) if singleton
-      nil
     end
 
     def get_super_method(ctx, singleton)
-      idx = ctx.cref.klass.idx
+      klass = ctx.cref.klass
       mid = ctx.mid
-      idx = @class_defs[idx].superclass
-      while idx
-        class_def = @class_defs[idx]
+      if klass.kind == :class
+        klass = klass.superclass
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          mthd = class_def.get_method(mid, singleton)
+          return mthd if mthd
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
         mthd = class_def.get_method(mid, singleton)
         return mthd if mthd
-        idx = class_def.superclass
       end
       nil
     end
@@ -505,12 +575,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)
@@ -719,7 +789,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)
@@ -731,7 +801,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)
@@ -772,11 +842,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
@@ -792,9 +862,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
@@ -819,7 +887,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
@@ -860,9 +928,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
@@ -897,9 +965,11 @@ 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)
@@ -916,7 +986,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
@@ -1082,31 +1152,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
@@ -1114,8 +1160,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
@@ -1132,35 +1178,30 @@ module TypeProf
           else
             if existing_klass != Type.any
               error(ep, "the class \"#{ id }\" is #{ existing_klass.screen_name(self) }")
-              id = :"#{ id }(dummy)"
             end
-            existing_klass = get_constant(cbase, id) # TODO: multiple return values
-            if existing_klass != Type.any
-              klass = existing_klass
-            else
-              if type == :class
-                if superclass.is_a?(Type::Class)
-                  # okay
-                elsif superclass == Type.any
-                  warn(ep, "superclass is any; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                elsif superclass == Type.nil
-                  superclass = Type::Builtin[:obj]
-                elsif superclass.is_a?(Type::Instance)
-                  warn(ep, "superclass is an instance; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                else
-                  warn(ep, "superclass is not a class; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                end
-              else # module
-                superclass = nil
-              end
-              if cbase == Type.any
-                klass = Type.any
+            if type == :class
+              if superclass.is_a?(Type::Class)
+                # okay
+              elsif superclass == Type.any
+                warn(ep, "superclass is any; Object is used instead")
+                superclass = Type::Builtin[:obj]
+              elsif superclass == Type.nil
+                superclass = Type::Builtin[:obj]
+              elsif superclass.is_a?(Type::Instance)
+                warn(ep, "superclass is an instance; Object is used instead")
+                superclass = Type::Builtin[:obj]
               else
-                klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+                warn(ep, "superclass is not a class; Object is used instead")
+                superclass = Type::Builtin[:obj]
               end
+            else # module
+              superclass = nil
+            end
+            if cbase == Type.any
+              klass = Type.any
+            else
+              klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+              add_superclass_type_args!(klass, superclass.type_params.map { Type.any }) if superclass
             end
           end
           singleton = false
@@ -1182,7 +1223,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)
@@ -1248,30 +1289,30 @@ module TypeProf
         end
       when :invokesuper
         env, recv, _, aargs = setup_actual_arguments(:method, operands, ep, env)
-
-        env, recv = localize_type(env.static_env.recv_ty, env, ep)
-        mid  = ep.ctx.mid
-        singleton = !recv.is_a?(Type::Instance) # TODO: any?
-        # XXX: need to support included module...
-        meths = get_super_method(ep.ctx, singleton) # TODO: multiple return values
-        if meths
-          meths.each do |meth|
-            # XXX: this decomposition is really needed??
-            # It calls `Object.new` with union receiver which causes an error, but
-            # it may be a fault of builtin Object.new implementation.
-            recv.each_child do |recv|
-              meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
-                nenv, ret_ty, = localize_type(ret_ty, env, ep)
-                nenv = nenv.push(ret_ty)
-                merge_env(ep.next, nenv)
+        mid = ep.ctx.mid
+        found = false
+        recv.each_child_global do |recv|
+          klass, singleton = recv.method_dispatch_info
+          next unless klass
+          get_all_super_methods(klass, singleton, ep.ctx.cref.klass, ep.ctx.mid) do |meths, klass|
+            found = true
+            meths.each do |meth|
+              # XXX: this decomposition is really needed??
+              # It calls `Object.new` with union receiver which causes an error, but
+              # it may be a fault of builtin Object.new implementation.
+              recv.each_child do |recv|
+                meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
+                  nenv, ret_ty, = localize_type(ret_ty, env, ep)
+                  nenv = nenv.push(ret_ty)
+                  merge_env(ep.next, nenv)
+                end
               end
             end
           end
-          return
-        else
-          error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
-          env = env.push(Type.any)
         end
+        return if found
+        error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
+        env = env.push(Type.any)
       when :invokebuiltin
         raise NotImplementedError
       when :leave
@@ -1495,9 +1536,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)
@@ -1663,9 +1702,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
@@ -1685,9 +1728,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 }
@@ -1909,7 +1952,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 }
@@ -1919,20 +1962,31 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, ep, env, &ctn)
-      meths = recv.get_method(mid, self)
-      if meths
-        meths.each do |meth|
-          meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
-        end
+      case recv
+      when Type::Void
+        error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+        ctn[Type.any, ep, env]
+      when Type::Any
+        ctn[Type.any, ep, env]
       else
-        case recv
-        when Type::Void
-          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-        when Type::Any
+        klass, singleton = recv.method_dispatch_info
+        meths = get_method(klass, singleton, mid) if klass
+        if meths
+          meths.each do |meth|
+            meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
+          end
         else
-          error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+          meths = get_method(klass, singleton, :method_missing) if klass
+          if meths
+            aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
+            meths.each do |meth|
+              meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+            end
+          else
+            error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+            ctn[Type.any, ep, env]
+          end
         end
-        ctn[Type.any, ep, env]
       end
     end
 
@@ -1947,6 +2001,34 @@ module TypeProf
       end
     end
 
+    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)
+        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
+
+          pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
+        end
+      else
+        # XXX: what to do?
+      end
+    end
+
     def show_block_signature(blks)
       bsig = nil
       ret_ty = Type.bot