typeprof 0.8.0 → 0.11.0

data/lib/typeprof/arguments.rb

@@ -3,6 +3,7 @@ module TypeProf
   class ActualArguments
     def initialize(lead_tys, rest_ty, kw_tys, blk_ty)
       @lead_tys = lead_tys
+      raise unless lead_tys
       @rest_ty = rest_ty
       @kw_tys = kw_tys # kw_tys should be {:key1 => Type, :key2 => Type, ...} or {nil => Type}
       raise if !kw_tys.is_a?(::Hash)
@@ -58,6 +59,7 @@ module TypeProf
           subst = Type.merge_substitution(subst, subst2)
         end
         msig.opt_tys.each do |farg|
+          break if aargs.empty?
           aarg = aargs.shift
           return nil unless subst2 = Type.match?(aarg, farg)
           subst = Type.merge_substitution(subst, subst2)

data/lib/typeprof/block.rb

@@ -29,7 +29,10 @@ module TypeProf
 
     def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
       blk_env = scratch.return_envs[@outer_ep]
-      blk_env = blk_env.replace_recv_ty(replace_recv_ty) if replace_recv_ty
+      if replace_recv_ty
+        replace_recv_ty = scratch.globalize_type(replace_recv_ty, caller_env, caller_ep)
+        blk_env = blk_env.replace_recv_ty(replace_recv_ty)
+      end
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
       scratch.add_block_signature!(self, aargs.to_block_signature)
@@ -119,11 +122,12 @@ module TypeProf
     def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
       if aargs.lead_tys.size >= 1
         recv = aargs.lead_tys[0]
+        recv = Type.any if recv == Type.bot
         aargs = ActualArguments.new(aargs.lead_tys[1..], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
       elsif aargs.rest_ty
         recv = aargs.rest_ty.elems.squash_or_any # XXX: need to shift
       else
-        raise
+        recv = Type.any
       end
 
       scratch.add_block_signature!(self, aargs.to_block_signature)
@@ -133,4 +137,38 @@ module TypeProf
       end
     end
   end
+
+  class CustomBlock < Block
+    def initialize(caller_ep, mid, &blk)
+      @caller_ep = caller_ep
+      @mid = mid
+      @blk = blk
+    end
+
+    def inspect
+      "#<CustomBlock>"
+    end
+
+    def consistent?(other)
+      true # XXX
+    end
+
+    def substitute(_subst, _depth)
+      self
+    end
+
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+      aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
+
+      dummy_ctx = TypedContext.new(@caller_ep, @mid)
+
+      scratch.add_block_signature!(self, aargs.to_block_signature)
+      scratch.add_block_to_ctx!(self, dummy_ctx)
+
+      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty) do |ret_ty, ep, env|
+        scratch.add_return_value!(dummy_ctx, ret_ty)
+        ctn[ret_ty, ep, env]
+      end
+    end
+  end
 end

data/lib/typeprof/builtin.rb

@@ -19,7 +19,7 @@ module TypeProf
       klass, new_mid, old_mid = aargs.lead_tys
       new_sym = get_sym("alias", new_mid, ep, scratch) or return
       old_sym = get_sym("alias", old_mid, ep, scratch) or return
-      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym)
+      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym, ep)
       ctn[Type.nil, ep, env]
     end
 
@@ -82,14 +82,17 @@ module TypeProf
     end
 
     def object_is_a?(recv, mid, aargs, ep, env, scratch, &ctn)
-      raise unless aargs.lead_tys.size != 0
-      if recv.is_a?(Type::Instance)
-        if recv.klass == aargs.lead_tys[0] # XXX: inheritance
-          true_val = Type::Instance.new(Type::Builtin[:true])
-          ctn[true_val, ep, env]
+      if aargs.lead_tys.size == 1
+        if recv.is_a?(Type::Instance)
+          if recv.klass == aargs.lead_tys[0] # XXX: inheritance
+            true_val = Type::Instance.new(Type::Builtin[:true])
+            ctn[true_val, ep, env]
+          else
+            false_val = Type::Instance.new(Type::Builtin[:false])
+            ctn[false_val, ep, env]
+          end
         else
-          false_val = Type::Instance.new(Type::Builtin[:false])
-          ctn[false_val, ep, env]
+          ctn[Type.bool, ep, env]
         end
       else
         ctn[Type.bool, ep, env]
@@ -97,16 +100,19 @@ module TypeProf
     end
 
     def object_respond_to?(recv, mid, aargs, ep, env, scratch, &ctn)
-      raise unless aargs.lead_tys.size != 0
-      sym = get_sym("respond_to?", aargs.lead_tys[0], ep, scratch)
-      if sym
-        klass, singleton = recv.method_dispatch_info
-        if scratch.get_method(klass, singleton, sym)
-          true_val = Type::Instance.new(Type::Builtin[:true])
-          ctn[true_val, ep, env]
+      if aargs.lead_tys.size == 1
+        sym = get_sym("respond_to?", aargs.lead_tys[0], ep, scratch)
+        if sym
+          klass, singleton = recv.method_dispatch_info
+          if scratch.get_method(klass, singleton, sym)
+            true_val = Type::Instance.new(Type::Builtin[:true])
+            ctn[true_val, ep, env]
+          else
+            false_val = Type::Instance.new(Type::Builtin[:false])
+            ctn[false_val, ep, env]
+          end
         else
-          false_val = Type::Instance.new(Type::Builtin[:false])
-          ctn[false_val, ep, env]
+          ctn[Type.bool, ep, env]
         end
       else
         ctn[Type.bool, ep, env]
@@ -124,10 +130,12 @@ module TypeProf
     def object_send(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size >= 1
         mid_ty, = aargs.lead_tys
-      else
+      elsif aargs.rest_ty
         mid_ty = aargs.rest_ty
+      else
+        return ctn[Type.any, ep, env]
       end
-      aargs = ActualArguments.new(aargs.lead_tys[1..-1], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
+      aargs = ActualArguments.new(aargs.lead_tys[1..] || [], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
       found = false
       mid_ty.each_child do |mid|
         if mid.is_a?(Type::Symbol)
@@ -148,8 +156,70 @@ module TypeProf
         return
       end
       naargs = ActualArguments.new([recv], nil, {}, Type.nil)
-      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: recv) do |_ret_ty, ep|
-        ctn[recv, ep, scratch.return_envs[ep]]
+      nrecv = recv
+      nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |_ret_ty, ep|
+        ctn[recv, ep, env]
+      end
+    end
+
+    def object_enum_for(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        mid_ty, = aargs.lead_tys
+        naargs = ActualArguments.new(aargs.lead_tys[1..], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
+      elsif aargs.rest_ty
+        mid_ty = aargs.rest_ty
+        naargs = aargs
+      else
+        mid_ty = Type::Symbol.new(:each, Type::Instance.new(Type::Builtin[:sym]))
+        naargs = aargs
+      end
+
+      elem_ty = Type.bot
+      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &blk_ctn|
+        if aargs.lead_tys.size >= 1
+          elem_ty = elem_ty.union(aargs.lead_tys[0])
+        else
+          elem_ty = elem_ty.union(Type.any)
+        end
+        ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+        blk_ctn[Type.any, caller_ep, caller_env]
+      end
+      enum_for_blk_ty = Type::Proc.new(enum_for_blk, Type::Instance.new(Type::Builtin[:proc]))
+
+      naargs = ActualArguments.new(naargs.lead_tys, naargs.rest_ty, naargs.kw_tys, enum_for_blk_ty)
+      mid_ty.each_child do |mid|
+        if mid.is_a?(Type::Symbol)
+          mid = mid.sym
+          scratch.do_send(recv, mid, naargs, ep, env) do |_ret_ty, _ep|
+            ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+          end
+        end
+      end
+    end
+
+    def object_privitive_method(recv, mid, aargs, ep, env, scratch, &ctn)
+      ctn[Type::Symbol.new(ep.ctx.mid, Type::Instance.new(Type::Builtin[:sym])), ep, env]
+    end
+
+    def object_block_given?(recv, mid, aargs, ep, env, scratch, &ctn)
+      procs = Type.bot
+      no_proc = false
+      env.static_env.blk_ty.each_child do |blk_ty|
+        case blk_ty
+        when Type::Proc
+          procs = procs.union(blk_ty)
+        when Type.nil
+          no_proc = true
+        else
+          ctn[Type.bool, ep, env]
+        end
+      end
+      if procs != Type.bot
+        ctn[Type::Instance.new(Type::Builtin[:true]), ep, env.replace_blk_ty(procs)]
+      end
+      if no_proc
+        ctn[Type::Instance.new(Type::Builtin[:false]), ep, env.replace_blk_ty(Type.nil)]
       end
     end
 
@@ -159,10 +229,16 @@ module TypeProf
         ctn[Type.any, ep, env]
         return
       end
+
+      unless recv.is_a?(Type::Class)
+        # XXX: warn?
+        return ctn[Type.any, ep, env]
+      end
+
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, false, ep.ctx.iseq.absolute_path)
+          scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -174,10 +250,38 @@ module TypeProf
         ctn[Type.any, ep, env]
         return
       end
+
+      unless recv.is_a?(Type::Class)
+        # XXX: warn?
+        return ctn[Type.any, ep, env]
+      end
+
+      arg = aargs.lead_tys[0]
+      arg.each_child do |arg|
+        if arg.is_a?(Type::Class)
+          # if ep.ctx.cref.singleton is true, the meta-meta level is ignored. Should we warn?
+          scratch.mix_module(:after, recv, arg, nil, true, ep)
+        end
+      end
+      ctn[recv, ep, env]
+    end
+
+    def module_prepend(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#prepend without an argument is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+
+      unless recv.is_a?(Type::Class)
+        # XXX: warn?
+        return ctn[Type.any, ep, env]
+      end
+
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, true, ep.ctx.iseq.absolute_path)
+          scratch.mix_module(:before, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -202,13 +306,17 @@ module TypeProf
       if aargs.lead_tys.empty?
         ctn[recv, ep, env.method_public_set(true)]
       else
-        aargs.lead_tys.each do |aarg|
-          sym = get_sym("public", aarg, ep, scratch) or next
-          meths = scratch.get_method(recv, false, sym)
-          next unless meths
-          meths.each do |mdef|
-            mdef.pub_meth = true
+        if recv.is_a?(Type::Class)
+          aargs.lead_tys.each do |aarg|
+            sym = get_sym("public", aarg, ep, scratch) or next
+            meths = scratch.get_method(recv, false, sym)
+            next unless meths
+            meths.each do |mdef|
+              mdef.pub_meth = true if mdef.respond_to?(:pub_meth=)
+            end
           end
+        else
+          # XXX: warn?
         end
         ctn[recv, ep, env]
       end
@@ -218,13 +326,17 @@ module TypeProf
       if aargs.lead_tys.empty?
         ctn[recv, ep, env.method_public_set(false)]
       else
-        aargs.lead_tys.each do |aarg|
-          sym = get_sym("private", aarg, ep, scratch) or next
-          meths = scratch.get_method(recv, false, sym)
-          next unless meths
-          meths.each do |mdef|
-            mdef.pub_meth = false
+        if recv.is_a?(Type::Class)
+          aargs.lead_tys.each do |aarg|
+            sym = get_sym("private", aarg, ep, scratch) or next
+            meths = scratch.get_method(recv, false, sym)
+            next unless meths
+            meths.each do |mdef|
+              mdef.pub_meth = false if mdef.respond_to?(:pub_meth=)
+            end
           end
+        else
+          # XXX: warn?
         end
         ctn[recv, ep, env]
       end
@@ -238,23 +350,25 @@ module TypeProf
       end
 
       mid, = aargs.lead_tys
-      if mid.is_a?(Type::Symbol)
-        mid = mid.sym
-        aargs.blk_ty.each_child do |blk_ty|
-          if blk_ty.is_a?(Type::Proc)
-            blk = blk_ty.block_body
-            case blk
-            when ISeqBlock
-              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, ep)
+      mid.each_child do |mid|
+        if mid.is_a?(Type::Symbol)
+          mid = mid.sym
+          aargs.blk_ty.each_child do |blk_ty|
+            if blk_ty.is_a?(Type::Proc)
+              blk = blk_ty.block_body
+              case blk
+              when ISeqBlock
+                scratch.do_define_iseq_method(ep, env, mid, blk.iseq, blk.outer_ep)
+              else
+                # XXX: what to do?
+              end
             else
               # XXX: what to do?
             end
-          else
-            # XXX: what to do?
           end
+        else
+          # XXX: what to do?
         end
-      else
-        # XXX: what to do?
       end
       ctn[Type.any, ep, env]
     end
@@ -263,7 +377,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_accessor", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :accessor)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :accessor, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -272,7 +386,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_reader", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :reader)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :reader, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -281,7 +395,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_writer", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :writer)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :writer, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -323,14 +437,19 @@ module TypeProf
       return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       if aargs.lead_tys.size != 2
+        # XXX: Support `ary[idx, len] = val`
         #raise NotImplementedError # XXX
-        ctn[Type.any, ep, env]
+        return ctn[Type.any, ep, env]
       end
 
       idx = aargs.lead_tys.first
       if idx.is_a?(Type::Literal)
         idx = idx.lit
-        raise NotImplementedError if !idx.is_a?(Integer)
+        if !idx.is_a?(Integer)
+          # XXX: Support `ary[idx..end] = val`
+          #raise NotImplementedError # XXX
+          return ctn[Type.any, ep, env]
+        end
       else
         idx = nil
       end
@@ -367,6 +486,7 @@ module TypeProf
       recv.each_child do |recv|
         if recv.is_a?(Type::Local) && recv.kind == Type::Hash
           ty = scratch.get_hash_elem_type(env, ep, recv.id, idx)
+          ty = Type.nil if ty == Type.bot
         else
           ty = Type.any
         end
@@ -377,7 +497,11 @@ module TypeProf
     def hash_aset(recv, mid, aargs, ep, env, scratch, &ctn)
       return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
 
-      raise NotImplementedError if aargs.lead_tys.size != 2
+      if aargs.lead_tys.size != 2
+        # XXX: error?
+        ctn[Type.any, ep, env]
+        return
+      end
 
       idx = aargs.lead_tys.first
       idx = scratch.globalize_type(idx, env, ep)
@@ -396,18 +520,7 @@ module TypeProf
     end
 
     def struct_initialize(recv, mid, aargs, ep, env, scratch, &ctn)
-      recv = Type::Instance.new(recv)
-      scratch.add_ivar_read!(recv, :_members, ep) do |member_ary_ty, ep|
-        member_ary_ty.elems.lead_tys.zip(aargs.lead_tys) do |sym, ty|
-          ty ||= Type.nil
-          scratch.set_instance_variable(recv, sym.sym, ty, ep, env)
-        end
-      end
-      ctn[recv, ep, env]
-    end
-
-    def struct_i_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      struct_klass = recv
+      struct_klass = recv.klass
       while struct_klass.superclass != Type::Builtin[:struct]
         struct_klass = struct_klass.superclass
       end
@@ -415,34 +528,57 @@ module TypeProf
         ctn[Type.any, ep, env]
         return
       end
-      if struct_klass != recv
-        scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |ty, ep|
-          scratch.add_ivar_write!(Type::Instance.new(recv), :_members, ty, ep)
-        end
-      end
-      meths = scratch.get_method(recv, false, :initialize)
-      meths.flat_map do |meth|
-        meth.do_send(recv, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
-          ctn[Type::Instance.new(recv), ep, env]
+      scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_keyword_init, ep) do |keyword_init, ep|
+        scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |member_ary_ty, ep|
+          next if member_ary_ty == Type.nil
+          if keyword_init == Type::Instance.new(Type::Builtin[:true])
+            # TODO: support kw_rest_ty
+            aargs.kw_tys.each do |key, val_ty|
+              found = false
+              member_ary_ty.elems.lead_tys.each do |sym|
+                if sym.sym == key
+                  found = true
+                  scratch.set_instance_variable(recv, sym.sym, val_ty, ep, env)
+                end
+              end
+              unless found
+                # TODO: what to do when not found?
+              end
+            end
+          else
+            member_ary_ty.elems.lead_tys.zip(aargs.lead_tys) do |sym, ty|
+              ty ||= Type.nil
+              scratch.set_instance_variable(recv, sym.sym, ty, ep, env)
+            end
+          end
         end
       end
+      ctn[recv, ep, env]
     end
 
     def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
       # TODO: keyword_init
 
+      keyword_init = false
+      if aargs.kw_tys && aargs.kw_tys[:keyword_init] # XXX: more canonical way to extract keyword...
+        if aargs.kw_tys[:keyword_init] == Type::Instance.new(Type::Builtin[:true])
+          keyword_init = true
+        end
+      end
+
       fields = aargs.lead_tys.map {|ty| get_sym("Struct.new", ty, ep, scratch) }.compact
       struct_klass = scratch.new_struct(ep)
 
-      scratch.set_singleton_custom_method(struct_klass, :new, Builtin.method(:struct_i_new))
-      scratch.set_singleton_custom_method(struct_klass, :[], Builtin.method(:struct_i_new))
+      scratch.set_singleton_custom_method(struct_klass, :new, Builtin.method(:object_s_new))
+      scratch.set_singleton_custom_method(struct_klass, :[], Builtin.method(:object_s_new))
       fields.each do |field|
-        scratch.add_attr_method(struct_klass, ep.ctx.iseq.absolute_path, field, field, :accessor)
+        scratch.add_attr_method(struct_klass, field, field, :accessor, true, ep)
       end
       fields = fields.map {|field| Type::Symbol.new(field, Type::Instance.new(Type::Builtin[:sym])) }
       base_ty = Type::Instance.new(Type::Builtin[:ary])
       fields = Type::Array.new(Type::Array::Elements.new(fields), base_ty)
       scratch.add_ivar_write!(Type::Instance.new(struct_klass), :_members, fields, ep)
+      scratch.add_ivar_write!(Type::Instance.new(struct_klass), :_keyword_init, Type::Instance.new(Type::Builtin[:true]), ep) if keyword_init
       #set_singleton_custom_method(struct_klass, :members, Builtin.method(:...))
 
       ctn[struct_klass, ep, env]
@@ -491,11 +627,20 @@ module TypeProf
     end
 
     def kernel_require(recv, mid, aargs, ep, env, scratch, &ctn)
-      raise NotImplementedError if aargs.lead_tys.size != 1
+      if aargs.lead_tys.size != 1
+        # XXX: handle correctly
+        ctn[Type.any, ep, env]
+        return
+      end
+
       feature = aargs.lead_tys.first
       if feature.is_a?(Type::Literal)
         feature = feature.lit
 
+        unless feature.is_a?(String)
+          return ctn[Type.any, ep, env]
+        end
+
         action, arg = Builtin.file_require(feature, scratch)
         case action
         when :do
@@ -505,22 +650,31 @@ module TypeProf
           ctn[result, ep, env]
         when :error
           scratch.warn(ep, arg)
-          result = Type::Instance.new(Type.bool)
+          result = Type.bool
           ctn[result, ep, env]
         end
       else
         scratch.warn(ep, "require target cannot be identified statically")
-        result = Type::Instance.new(Type.bool)
+        result = Type.bool
         ctn[result, ep, env]
       end
     end
 
     def kernel_require_relative(recv, mid, aargs, ep, env, scratch, &ctn)
-      raise NotImplementedError if aargs.lead_tys.size != 1
+      if aargs.lead_tys.size != 1
+        # XXX: handle correctly
+        ctn[Type.any, ep, env]
+        return
+      end
+
       feature = aargs.lead_tys.first
       if feature.is_a?(Type::Literal)
         feature = feature.lit
 
+        unless feature.is_a?(String)
+          return ctn[Type.any, ep, env]
+        end
+
         if scratch.loaded_features[feature]
           result = Type::Instance.new(Type::Builtin[:false])
           return ctn[result, ep, env]
@@ -541,7 +695,12 @@ module TypeProf
     end
 
     def kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
-      raise NotImplementedError if aargs.lead_tys.size != 2
+      if aargs.lead_tys.size != 2
+        # XXX: handle correctly
+        ctn[Type.any, ep, env]
+        return
+      end
+
       feature = aargs.lead_tys[1]
       if feature.is_a?(Type::Literal)
         feature = feature.lit
@@ -593,23 +752,26 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
-      Type::Builtin[:int]       = scratch.get_constant(klass_obj, :Integer)
-      Type::Builtin[:float]     = scratch.get_constant(klass_obj, :Float)
-      Type::Builtin[:rational]  = scratch.get_constant(klass_obj, :Rational)
-      Type::Builtin[:sym]       = scratch.get_constant(klass_obj, :Symbol)
-      Type::Builtin[:str]       = scratch.get_constant(klass_obj, :String)
-      Type::Builtin[:struct]    = scratch.get_constant(klass_obj, :Struct)
-      Type::Builtin[:ary]       = scratch.get_constant(klass_obj, :Array)
-      Type::Builtin[:hash]      = scratch.get_constant(klass_obj, :Hash)
-      Type::Builtin[:io]        = scratch.get_constant(klass_obj, :IO)
-      Type::Builtin[:proc]      = scratch.get_constant(klass_obj, :Proc)
-      Type::Builtin[:range]     = scratch.get_constant(klass_obj, :Range)
-      Type::Builtin[:regexp]    = scratch.get_constant(klass_obj, :Regexp)
-      Type::Builtin[:matchdata] = scratch.get_constant(klass_obj, :MatchData)
-      Type::Builtin[:class]     = scratch.get_constant(klass_obj, :Class)
-      Type::Builtin[:module]    = scratch.get_constant(klass_obj, :Module)
-      Type::Builtin[:exc]       = scratch.get_constant(klass_obj, :Exception)
+      Type::Builtin[:vmcore]     = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
+      Type::Builtin[:int]        = scratch.get_constant(klass_obj, :Integer)
+      Type::Builtin[:float]      = scratch.get_constant(klass_obj, :Float)
+      Type::Builtin[:rational]   = scratch.get_constant(klass_obj, :Rational)
+      Type::Builtin[:complex]    = scratch.get_constant(klass_obj, :Complex)
+      Type::Builtin[:sym]        = scratch.get_constant(klass_obj, :Symbol)
+      Type::Builtin[:str]        = scratch.get_constant(klass_obj, :String)
+      Type::Builtin[:struct]     = scratch.get_constant(klass_obj, :Struct)
+      Type::Builtin[:ary]        = scratch.get_constant(klass_obj, :Array)
+      Type::Builtin[:hash]       = scratch.get_constant(klass_obj, :Hash)
+      Type::Builtin[:io]         = scratch.get_constant(klass_obj, :IO)
+      Type::Builtin[:proc]       = scratch.get_constant(klass_obj, :Proc)
+      Type::Builtin[:range]      = scratch.get_constant(klass_obj, :Range)
+      Type::Builtin[:regexp]     = scratch.get_constant(klass_obj, :Regexp)
+      Type::Builtin[:matchdata]  = scratch.get_constant(klass_obj, :MatchData)
+      Type::Builtin[:class]      = scratch.get_constant(klass_obj, :Class)
+      Type::Builtin[:module]     = scratch.get_constant(klass_obj, :Module)
+      Type::Builtin[:exc]        = scratch.get_constant(klass_obj, :Exception)
+      Type::Builtin[:encoding]   = scratch.get_constant(klass_obj, :Encoding)
+      Type::Builtin[:enumerator] = scratch.get_constant(klass_obj, :Enumerator)
 
       klass_vmcore = Type::Builtin[:vmcore]
       klass_ary    = Type::Builtin[:ary]
@@ -624,23 +786,29 @@ module TypeProf
       scratch.set_custom_method(klass_vmcore, :"core#raise", Builtin.method(:vmcore_raise))
       scratch.set_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
       scratch.set_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
-      scratch.set_singleton_custom_method(klass_obj, :"attr_accessor", Builtin.method(:module_attr_accessor))
-      scratch.set_singleton_custom_method(klass_obj, :"attr_reader", Builtin.method(:module_attr_reader))
-      scratch.set_singleton_custom_method(klass_obj, :"attr_writer", Builtin.method(:module_attr_writer))
-      scratch.set_custom_method(klass_obj, :p, Builtin.method(:kernel_p))
+      scratch.set_custom_method(klass_obj, :p, Builtin.method(:kernel_p), false)
       scratch.set_custom_method(klass_obj, :is_a?, Builtin.method(:object_is_a?))
       scratch.set_custom_method(klass_obj, :respond_to?, Builtin.method(:object_respond_to?))
       scratch.set_custom_method(klass_obj, :class, Builtin.method(:object_class))
       scratch.set_custom_method(klass_obj, :send, Builtin.method(:object_send))
       scratch.set_custom_method(klass_obj, :instance_eval, Builtin.method(:object_instance_eval))
-      scratch.set_custom_method(klass_obj, :proc, Builtin.method(:lambda))
+      scratch.set_custom_method(klass_obj, :proc, Builtin.method(:lambda), false)
+      scratch.set_custom_method(klass_obj, :__method__, Builtin.method(:object_privitive_method), false)
+      scratch.set_custom_method(klass_obj, :block_given?, Builtin.method(:object_block_given?), false)
+
+      scratch.set_custom_method(klass_obj, :enum_for, Builtin.method(:object_enum_for))
+      scratch.set_custom_method(klass_obj, :to_enum, Builtin.method(:object_enum_for))
 
       scratch.set_custom_method(klass_module, :include, Builtin.method(:module_include))
       scratch.set_custom_method(klass_module, :extend, Builtin.method(:module_extend))
-      scratch.set_custom_method(klass_module, :module_function, Builtin.method(:module_module_function))
-      scratch.set_custom_method(klass_module, :public, Builtin.method(:module_public))
-      scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private))
+      scratch.set_custom_method(klass_module, :prepend, Builtin.method(:module_prepend))
+      scratch.set_custom_method(klass_module, :module_function, Builtin.method(:module_module_function), false)
+      scratch.set_custom_method(klass_module, :public, Builtin.method(:module_public), false)
+      scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private), false)
       scratch.set_custom_method(klass_module, :define_method, Builtin.method(:module_define_method))
+      scratch.set_custom_method(klass_module, :"attr_accessor", Builtin.method(:module_attr_accessor))
+      scratch.set_custom_method(klass_module, :"attr_reader", Builtin.method(:module_attr_reader))
+      scratch.set_custom_method(klass_module, :"attr_writer", Builtin.method(:module_attr_writer))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))
@@ -655,10 +823,10 @@ module TypeProf
       scratch.set_custom_method(klass_struct, :initialize, Builtin.method(:struct_initialize))
       scratch.set_singleton_custom_method(klass_struct, :new, Builtin.method(:struct_s_new))
 
-      scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require))
-      scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative))
-      scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array))
-      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload))
+      scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require), false)
+      scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative), false)
+      scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array), false)
+      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload), false)
       scratch.set_custom_method(klass_module, :autoload, Builtin.method(:module_autoload))
 
       # remove BasicObject#method_missing