typeprof 0.6.0 → 0.9.1

data/lib/typeprof/export.rb

@@ -72,7 +72,7 @@ module TypeProf
       gvars.dump.each do |gvar_name, entry|
         next if entry.type == Type.bot
         s = entry.rbs_declared ? "#" : ""
-        output.puts s + "#{ gvar_name } : #{ entry.type.screen_name(scratch) }"
+        output.puts s + "#{ gvar_name }: #{ entry.type.screen_name(scratch) }"
       end
       output.puts
     end
@@ -135,11 +135,12 @@ module TypeProf
               method_name = ctx.mid
               method_name = "self.#{ method_name }" if singleton
 
-              iseq_methods[method_name] ||= []
-              iseq_methods[method_name] << @scratch.show_method_signature(ctx)
+              iseq_methods[method_name] ||= [true, []]
+              iseq_methods[method_name][0] &&= mdef.pub_meth
+              iseq_methods[method_name][1] << @scratch.show_method_signature(ctx)
             end
           when AttrMethodDef
-            next if Config.check_dir_filter(mdef.absolute_path) == :exclude
+            next if !mdef.absolute_path || Config.check_dir_filter(mdef.absolute_path) == :exclude
             mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
             method_name = mid
             method_name = "self.#{ mid }" if singleton
@@ -168,12 +169,14 @@ module TypeProf
         next unless var.to_s.start_with?("@")
         var = "self.#{ var }" if singleton
         next if attr_methods[[singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]
-        [var, ty.screen_name(@scratch), entry.rbs_declared]
+        next if entry.rbs_declared
+        [var, ty.screen_name(@scratch)]
       end.compact
 
       cvars = cvars.map do |var, entry|
         next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
-        [var, entry.type.screen_name(@scratch), entry.rbs_declared]
+        next if entry.rbs_declared
+        [var, entry.type.screen_name(@scratch)]
       end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
@@ -266,7 +269,7 @@ module TypeProf
       output.puts indent + "#{ class_data.kind } #{ name }#{ superclass }"
       first = true
       class_data.consts.each do |name, ty|
-        output.puts indent + "  #{ name } : #{ ty }"
+        output.puts indent + "  #{ name }: #{ ty }"
         first = false
       end
       class_data.included_mods.sort.each do |mod|
@@ -277,28 +280,31 @@ module TypeProf
         output.puts indent + "  extend #{ mod }"
         first = false
       end
-      class_data.ivars.each do |var, ty, rbs_declared|
-        s = rbs_declared ? "# " : "  "
-        output.puts indent + s + "#{ var } : #{ ty }" unless var.start_with?("_")
+      class_data.ivars.each do |var, ty|
+        output.puts indent + "  #{ var }: #{ ty }" unless var.start_with?("_")
         first = false
       end
-      class_data.cvars.each do |var, ty, rbs_declared|
-        s = rbs_declared ? "# " : "  "
-        output.puts indent + s + "#{ var } : #{ ty }"
+      class_data.cvars.each do |var, ty|
+        output.puts indent + "  #{ var }: #{ ty }"
         first = false
       end
       class_data.attr_methods.each do |(method_name, hidden), (kind, ty)|
-        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" } : #{ ty }"
+        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
         first = false
       end
       class_data.explicit_methods.each do |method_name, sigs|
         sigs = sigs.sort.join("\n" + indent + "#" + " " * (method_name.size + 6) + "| ")
-        output.puts indent + "# def #{ method_name } : #{ sigs }"
+        output.puts indent + "# def #{ method_name }: #{ sigs }"
         first = false
       end
-      class_data.iseq_methods.each do |method_name, sigs|
+      prev_pub_meth = true
+      class_data.iseq_methods.each do |method_name, (pub_meth, sigs)|
         sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 7) + "| ")
-        output.puts indent + "  def #{ method_name } : #{ sigs }"
+        if prev_pub_meth != pub_meth
+          output.puts indent + "  #{ pub_meth ? "public" : "private" }"
+          prev_pub_meth = pub_meth
+        end
+        output.puts indent + "  def #{ method_name }: #{ sigs }"
         first = false
       end
       show_class_hierarchy(depth + 1, class_data.inner_classes, output, first)

data/lib/typeprof/import.rb

@@ -26,6 +26,13 @@ module TypeProf
     def load_library(lib)
       loader = RBS::EnvironmentLoader.new(core_root: nil)
       loader.add(library: lib)
+
+      case lib
+      when "yaml"
+        loader.add(library: "pstore")
+        loader.add(library: "dbm")
+      end
+
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
@@ -112,6 +119,7 @@ module TypeProf
         included_modules = []
         extended_modules = []
         methods = {}
+        attr_methods = {}
         ivars = {}
         cvars = {}
         rbs_sources = {}
@@ -147,15 +155,15 @@ module TypeProf
               end
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
-              methods[[false, member.name]] = attr_reader_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
-              methods[[false, :"#{ member.name }="]] = attr_writer_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
-              methods[[false, member.name]] = attr_reader_def(ty)
-              methods[[false, :"#{ member.name }="]] = attr_writer_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty)
             when RBS::AST::Members::Alias
+              # XXX: an alias to attr methods?
               if member.instance?
                 method_def = methods[[false, member.old_name]]
                 methods[[false, member.new_name]] = method_def if method_def
@@ -211,6 +219,7 @@ module TypeProf
             included_modules: included_modules,
             extended_modules: extended_modules,
             methods: methods,
+            attr_methods: attr_methods,
             ivars: ivars,
             cvars: cvars,
             rbs_sources: rbs_sources,
@@ -237,7 +246,7 @@ module TypeProf
             @all_env.class_decls[name].decls.each do |decl|
               decl = decl.decl
               next if decl.is_a?(RBS::AST::Declarations::Module)
-              each_ancestor(decl) {|name| queue << [:visit, name] }
+              each_reference(decl) {|name| queue << [:visit, name] }
             end
             queue << [:visit, name.namespace.to_type_name] if !name.namespace.empty?
           end
@@ -252,13 +261,20 @@ module TypeProf
       end
     end
 
-    def each_ancestor(decl, &blk)
+    def each_reference(decl, &blk)
       yield decl.name
-      super_class = decl.super_class || RBS::BuiltinNames::Object
+      if decl.super_class
+        name = decl.super_class.name
+      else
+        name = RBS::BuiltinNames::Object.name
+      end
       return if decl.name == RBS::BuiltinNames::BasicObject.name
-      return if decl.name == super_class.name
-      @all_env.class_decls[super_class.name].decls.each do |decl|
-        each_ancestor(decl.decl, &blk)
+      return if decl.name == name
+      decls = @all_env.class_decls[name]
+      if decls
+        decls.decls.each do |decl|
+          each_reference(decl.decl, &blk)
+        end
       end
     end
 
@@ -297,7 +313,7 @@ module TypeProf
       opt_kw_tys = func.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
       req_kw_tys = func.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
       rest_kw_ty = func.rest_keywords
-      raise NotImplementedError if rest_kw_ty # XXX
+      rest_kw_ty = conv_type(rest_kw_ty.type) if rest_kw_ty
 
       ret_ty = conv_type(func.return_type)
 
@@ -314,32 +330,12 @@ module TypeProf
       }
     end
 
-    def attr_reader_def(ty)
-      [{
-        type_params: [],
-        lead_tys: [],
-        opt_tys: [],
-        rest_ty: nil,
-        req_kw_tys: {},
-        opt_kw_tys: {},
-        rest_kw_ty: nil,
-        blk: nil,
-        ret_ty: ty,
-      }]
-    end
-
-    def attr_writer_def(ty)
-      [{
-        type_params: [],
-        lead_tys: [ty],
-        opt_tys: [],
-        rest_ty: nil,
-        req_kw_tys: {},
-        opt_kw_tys: {},
-        rest_kw_ty: nil,
-        blk: nil,
-        ret_ty: ty,
-      }]
+    def attr_method_def(kind, name, ty)
+      {
+        kind: kind,
+        ivar: name,
+        ty: ty,
+      }
     end
 
     def conv_block(rbs_block)
@@ -452,6 +448,8 @@ module TypeProf
         json = scratch.rbs_reader.load_library(feature)
       rescue RBS::EnvironmentLoader::UnknownLibraryError
         return nil
+      rescue RBS::DuplicatedDeclarationError
+        return true
       end
       # need cache?
       Import.new(scratch, json).import
@@ -483,8 +481,7 @@ module TypeProf
 
         klass = @scratch.get_constant(base_klass, name)
         if klass.is_a?(Type::Any)
-          superclass_type_args = superclass_type_args&.map {|ty| conv_type(ty) }
-          klass = @scratch.new_class(base_klass, name, type_params, superclass, superclass_type_args, nil)
+          klass = @scratch.new_class(base_klass, name, type_params, superclass, nil)
 
           # There builtin classes are needed to interpret RBS declarations
           case classpath
@@ -500,13 +497,15 @@ module TypeProf
           end
         end
 
-        [klass, members]
+        [klass, superclass_type_args, members]
       end
 
-      classes.each do |klass, members|
+      classes.each do |klass, superclass_type_args, members|
+        @scratch.add_superclass_type_args!(klass, superclass_type_args&.map {|ty| conv_type(ty) })
         included_modules = members[:included_modules]
         extended_modules = members[:extended_modules]
         methods = members[:methods]
+        attr_methods = members[:attr_methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
@@ -527,6 +526,14 @@ module TypeProf
           @scratch.add_method(klass, method_name, singleton, mdef)
         end
 
+        attr_methods.each do |(singleton, method_name), mdef|
+          kind = mdef[:kind]
+          ivar = mdef[:ivar]
+          ty = conv_type(mdef[:ty]).remove_type_vars
+          @scratch.add_attr_method(klass, nil, ivar, :"@#{ ivar }", kind)
+          @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
+        end
+
         ivars.each do |ivar_name, ty|
           ty = conv_type(ty).remove_type_vars
           @scratch.add_ivar_write!(Type::Instance.new(klass), ivar_name, ty, nil)
@@ -593,7 +600,7 @@ module TypeProf
       req, lead_tys, opt_tys, ret_ty = blk
       lead_tys = lead_tys.map {|ty| conv_type(ty) }
       opt_tys = opt_tys.map {|ty| conv_type(ty) }
-      msig = MethodSignature.new(lead_tys, opt_tys, nil, nil, nil, nil, nil)
+      msig = MethodSignature.new(lead_tys, opt_tys, nil, [], {}, nil, Type.nil)
       ret_ty = conv_type(ret_ty)
       ret = [Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Builtin[:proc])]
       ret << Type.nil unless req

data/lib/typeprof/iseq.rb

@@ -49,10 +49,18 @@ module TypeProf
         insns[i, 0] = [[:_iseq_body_start]]
       end
 
+      # rescue/ensure clauses need to have a dedicated return addresses
+      # because they requires to be virtually called.
+      # So, this preprocess adds "nop" to make a new insn for their return addresses
+      special_labels = {}
+      catch_table.map do |type, iseq, first, last, cont, stack_depth|
+        special_labels[cont] = true if type == :rescue || type == :ensure
+      end
+
       @insns = []
       @linenos = []
 
-      labels = setup_iseq(insns)
+      labels = setup_iseq(insns, special_labels)
 
       # checkmatch->branch
       # send->branch
@@ -60,7 +68,8 @@ module TypeProf
       @catch_table = []
       catch_table.map do |type, iseq, first, last, cont, stack_depth|
         iseq = iseq ? ISeq.new(iseq) : nil
-        entry = [type, iseq, labels[cont], stack_depth]
+        target = labels[special_labels[cont] ? :"#{ cont }_special" : cont]
+        entry = [type, iseq, target, stack_depth]
         labels[first].upto(labels[last]) do |i|
           @catch_table[i] ||= []
           @catch_table[i] << entry
@@ -76,19 +85,26 @@ module TypeProf
       @id <=> other.id
     end
 
-    def setup_iseq(insns)
+    def setup_iseq(insns, special_labels)
       i = 0
       labels = {}
+      ninsns = []
       insns.each do |e|
         if e.is_a?(Symbol) && e.to_s.start_with?("label")
+          if special_labels[e]
+            labels[:"#{ e }_special"] = i
+            ninsns << [:nop]
+            i += 1
+          end
           labels[e] = i
-        elsif e.is_a?(Array)
-          i += 1
+        else
+          i += 1 if e.is_a?(Array)
+          ninsns << e
         end
       end
 
       lineno = 0
-      insns.each do |e|
+      ninsns.each do |e|
         case e
         when Integer # lineno
           lineno = e
@@ -209,7 +225,7 @@ module TypeProf
         end
       end
       send_branch_list.each do |i, j|
-        next if (i + 1 .. j).any? {|i| branch_targets[i] }
+        next if (i + 1 .. j + 1).any? {|i| branch_targets[i] }
         _insn, getlocal_operands = @insns[i]
         _insn, send_operands = @insns[j]
         _insn, branch_operands = @insns[j + 1]

data/lib/typeprof/method.rb

@@ -4,12 +4,16 @@ module TypeProf
   end
 
   class ISeqMethodDef < MethodDef
-    def initialize(iseq, cref)
+    def initialize(iseq, cref, outer_ep, pub_meth)
       @iseq = iseq
       raise if iseq.nil?
       @cref = cref
+      @outer_ep = outer_ep
+      @pub_meth = pub_meth
     end
 
+    attr_accessor :pub_meth
+
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
@@ -25,8 +29,8 @@ module TypeProf
       end
 
       nctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(nctx, 0, nil)
-      nenv = Env.new(StaticEnv.new(recv, blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
+      nenv = Env.new(StaticEnv.new(recv, blk_ty, false, true), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       locals.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(i)
@@ -44,6 +48,14 @@ module TypeProf
     end
 
     def do_check_send(msig, recv, mid, ep, scratch)
+      klass, singleton = recv.method_dispatch_info
+      cur_subst = {}
+      direct_method = true
+      scratch.adjust_substitution(klass, singleton, mid, self, recv.generate_substitution) do |subst, direct|
+        direct_method &&= direct
+        cur_subst = Type.merge_substitution(cur_subst, subst)
+      end
+
       lead_num = @iseq.fargs_format[:lead_num] || 0
       post_num = @iseq.fargs_format[:post_num] || 0
       rest_start = @iseq.fargs_format[:rest_start]
@@ -67,63 +79,75 @@ module TypeProf
       post_start = @iseq.fargs_format[:post_start]
       rest_start = @iseq.fargs_format[:rest_start]
       kw_start = @iseq.fargs_format[:kwbits]
-      kw_start -= @iseq.fargs_format[:keyword].size if kw_start
+      keyword = @iseq.fargs_format[:keyword]
+      kw_start -= keyword.size if kw_start
       kw_rest = @iseq.fargs_format[:kwrest]
       block_start = @iseq.fargs_format[:block_start]
 
       # XXX: need to check .rbs msig and .rb fargs
 
       ctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(ctx, 0, nil)
+      callee_ep = ExecutionPoint.new(ctx, 0, @outer_ep)
 
       locals = [Type.nil] * @iseq.locals.size
-      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false), locals, [], Utils::HashWrapper.new({}))
+      nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false, true), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       idx = 0
       msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
-        # nenv is top-level, so it is okay to call Type#localize directly
-        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(i, ty)
       end
       if msig.opt_tys
         msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(lead_num + i, ty)
         end
       end
       if msig.rest_ty
         alloc_site2 = alloc_site.add_id(idx += 1)
         ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
-        nenv, rest_ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        nenv, rest_ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(rest_start, rest_ty)
       end
       if msig.post_tys
         msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
-      if msig.kw_tys
-        msig.kw_tys.each_with_index do |(_, key, ty), i|
+      if msig.kw_tys && keyword # TODO: support the case where RBS writes kw_tys and RB method accepts **kwrest
+        msig.kw_tys.each do |_, key, ty|
+          i = keyword.index {|callee_key,| callee_key == key }
+          unless i
+            # warn
+            next
+          end
           alloc_site2 = alloc_site.add_id(key)
-          nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
       if msig.kw_rest_ty
         ty = msig.kw_rest_ty
         alloc_site2 = alloc_site.add_id(:**)
-        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(kw_rest, ty)
       end
       nenv = nenv.local_update(block_start, msig.blk_ty) if block_start
 
       opt.each do |start_pc|
-        scratch.merge_env(ExecutionPoint.new(ctx, start_pc, nil), nenv)
+        scratch.merge_env(callee_ep.jump(start_pc), nenv)
       end
+      scratch.add_executed_iseq(@iseq)
 
       ctx
     end
@@ -142,8 +166,8 @@ module TypeProf
       case @kind
       when :reader
         if aargs.lead_tys.size == 0
-          scratch.get_instance_variable(recv, @ivar, caller_ep, caller_env) do |ty, nenv|
-            ctn[ty, caller_ep, nenv]
+          scratch.add_ivar_read!(recv, @ivar, caller_ep) do |ty, _ep|
+            ctn[ty, caller_ep, caller_env]
           end
         else
           ctn[Type.any, caller_ep, caller_env]
@@ -171,30 +195,11 @@ module TypeProf
     def do_send(recv_orig, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = scratch.globalize_type(recv_orig, caller_env, caller_ep)
 
-      tmp_subst = {}
-      case
-      when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
-        tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
-        tyvars.zip(recv.elems.elems) do |tyvar, elem|
-          if tmp_subst[tyvar]
-            tmp_subst[tyvar] = tmp_subst[tyvar].union(elem)
-          else
-            tmp_subst[tyvar] = elem
-          end
-        end
-      when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
-        tmp_subst = { Type::Var.new(:Elem) => recv.elems.squash }
-      when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
-        tyvar_k = Type::Var.new(:K)
-        tyvar_v = Type::Var.new(:V)
-        k_ty0, v_ty0 = recv.elems.squash
-        # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
-        tmp_subst = { tyvar_k => k_ty0, tyvar_v => v_ty0 }
-      end
-
       klass, singleton = recv_orig.method_dispatch_info
       cur_subst = {}
-      scratch.generate_substitution(klass, singleton, mid, self, tmp_subst) do |subst|
+      direct_method = true
+      scratch.adjust_substitution(klass, singleton, mid, self, recv.generate_substitution) do |subst, direct|
+        direct_method &&= direct
         cur_subst = Type.merge_substitution(cur_subst, subst)
       end
 
@@ -206,45 +211,15 @@ module TypeProf
         # XXX: support self type in msig
         subst = aargs.consistent_with_method_signature?(msig)
         next unless subst
-        case
-        when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
-          tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
-          # XXX: This should be skipped when the called methods belongs to superclass
-          tyvars.each_with_index do |tyvar, idx|
-            ty = subst[tyvar]
-            if ty
-              ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                elems.update(idx, ty)
-              end
-            end
-          end
-        when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
-          tyvar_elem = Type::Var.new(:Elem)
-          if subst[tyvar_elem]
-            ty = subst[tyvar_elem]
-            ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-              elems.update(nil, ty)
-            end
-          end
-        when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
-          tyvar_k = Type::Var.new(:K)
-          tyvar_v = Type::Var.new(:V)
-          if subst[tyvar_k] && subst[tyvar_v]
-            k_ty = subst[tyvar_k]
-            v_ty = subst[tyvar_v]
-            alloc_site = AllocationSite.new(caller_ep)
-            ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
-            ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-              elems.update(k_ty, v_ty)
-            end
-          end
+
+        if direct_method && recv_orig.is_a?(Type::Local)
+          ncaller_env = recv_orig.update_container_elem_type(subst, ncaller_env, caller_ep, scratch)
         end
+
         subst = Type.merge_substitution(subst, cur_subst)
         # need to check self tyvar?
         subst[Type::Var.new(:self)] = recv
+
         found = true
         if aargs.blk_ty.is_a?(Type::Proc)
           #raise NotImplementedError unless aargs.blk_ty.block_body.is_a?(ISeqBlock) # XXX
@@ -252,91 +227,33 @@ module TypeProf
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
           s_recv = recv
           s_recv = s_recv.base_type while s_recv.respond_to?(:base_type)
-          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
+          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false, true), [], [], Utils::HashWrapper.new({}))
           if msig.blk_ty.is_a?(Type::Proc)
             scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
-            nfargs = msig.blk_ty.block_body.msig
+            bsig = msig.blk_ty.block_body.msig
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
-            nlead_tys = (nfargs.lead_tys + nfargs.opt_tys).map.with_index do |ty, i|
-              if recv.is_a?(Type::Array)
-                tyvar_elem = Type::Var.new(:Elem)
-                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash_or_any }), Config.options[:type_depth_limit])
-              else
-                ty = ty.substitute(subst, Config.options[:type_depth_limit])
-              end
-              ty = ty.remove_type_vars
-              alloc_site2 = alloc_site.add_id(i)
-              dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site2)
+            nlead_tys = (bsig.lead_tys + bsig.opt_tys).map.with_index do |ty, i|
+              ty = ty.substitute(subst, Config.options[:type_depth_limit]).remove_type_vars
+              dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site.add_id(i))
               ty
             end
-            0.upto(nfargs.opt_tys.size) do |n|
-              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
+            0.upto(bsig.opt_tys.size) do |n|
+              naargs = ActualArguments.new(nlead_tys[0, bsig.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
               scratch.do_invoke_block(aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
                 subst2 = Type.match?(blk_ret_ty, msig.blk_ty.block_body.ret_ty)
                 if subst2
                   subst2 = Type.merge_substitution(subst, subst2)
-                  case
-                  when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
-                    tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
-                    tyvars.each_with_index do |tyvar, idx|
-                      ty = subst2[tyvar]
-                      if ty
-                        ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-                        ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                          elems.update(idx, ty)
-                        end
-                        scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                      end
-                    end
-                    tyvars.zip(recv.elems.elems) do |tyvar, elem|
-                      if subst2[tyvar]
-                        subst2[tyvar] = subst2[tyvar].union(elem)
-                      else
-                        subst2[tyvar] = elem
-                      end
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
-                    tyvar_elem = Type::Var.new(:Elem)
-                    if subst2[tyvar_elem]
-                      ty = subst2[tyvar_elem]
-                      ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                        elems.update(nil, ty)
-                      end
-                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
-                    tyvar_k = Type::Var.new(:K)
-                    tyvar_v = Type::Var.new(:V)
-                    k_ty0, v_ty0 = recv.elems.squash
-                    if subst2[tyvar_k] && subst2[tyvar_v]
-                      k_ty = subst2[tyvar_k]
-                      v_ty = subst2[tyvar_v]
-                      k_ty0 = k_ty0.union(k_ty)
-                      v_ty0 = v_ty0.union(v_ty)
-                      alloc_site = AllocationSite.new(caller_ep)
-                      ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
-                      ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                        elems.update(k_ty, v_ty)
-                      end
-                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  else
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  if direct_method && recv_orig.is_a?(Type::Local)
+                    ncaller_env = recv_orig.update_container_elem_type(subst2, ncaller_env, caller_ep, scratch)
+                    scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                   end
+                  ret_ty2 = ret_ty.substitute(subst2, Config.options[:type_depth_limit]).remove_type_vars
                 else
-                  # raise "???"
-                  # XXX: need warning
-                  ret_ty = Type.any
+                  ret_ty2 = Type.any
                 end
-                ret_ty = ret_ty.remove_type_vars
                 # XXX: check the return type from the block
                 # sig.blk_ty.block_body.ret_ty.eql?(_ret_ty) ???
-                scratch.add_return_value!(dummy_ctx, ret_ty)
+                scratch.add_return_value!(dummy_ctx, ret_ty2)
               end
               # scratch.add_return_value!(dummy_ctx, ret_ty) ?
               # This makes `def foo; 1.times { return "str" }; end` return Integer|String
@@ -374,7 +291,6 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
-      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env } # for Kernel#lambda
       @impl[recv, mid, aargs, caller_ep, caller_env, scratch, &ctn]
     end
   end