typeprof 0.9.1 → 0.13.0

data/lib/typeprof/block.rb

@@ -27,7 +27,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       blk_env = scratch.return_envs[@outer_ep]
       if replace_recv_ty
         replace_recv_ty = scratch.globalize_type(replace_recv_ty, caller_env, caller_ep)
@@ -46,7 +46,8 @@ module TypeProf
         return
       end
 
-      nctx = Context.new(@iseq, @outer_ep.ctx.cref, nil)
+      cref = replace_cref || @outer_ep.ctx.cref
+      nctx = Context.new(@iseq, cref, nil)
       callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
       nenv = Env.new(blk_env.static_env, locals, [], nil)
       alloc_site = AllocationSite.new(callee_ep)
@@ -87,7 +88,7 @@ module TypeProf
       TypedBlock.new(msig, ret_ty)
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
       subst = aargs.consistent_with_method_signature?(@msig)
       unless subst
@@ -119,7 +120,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       if aargs.lead_tys.size >= 1
         recv = aargs.lead_tys[0]
         recv = Type.any if recv == Type.bot
@@ -137,4 +138,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:, replace_cref:, &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, replace_cref: replace_cref) 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
 
@@ -158,11 +158,86 @@ module TypeProf
       naargs = ActualArguments.new([recv], nil, {}, Type.nil)
       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|
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |ret_ty, ep|
+        ctn[ret_ty, ep, env]
+      end
+    end
+
+    def object_module_eval(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        scratch.warn(ep, "class_eval with arguments is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+      naargs = ActualArguments.new([recv], nil, {}, Type.nil)
+      nrecv = recv
+      nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
+      ncref = ep.ctx.cref.extend(nrecv, true)
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv, replace_cref: ncref) 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:, replace_cref:, &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
+
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size != 1
         scratch.warn(ep, "Module#include without an argument is ignored")
@@ -175,10 +250,13 @@ module TypeProf
         return ctn[Type.any, ep, env]
       end
 
+      # support multiple arguments: include M1, M2
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, false, ep)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :included, aargs, ep, env) {|_ret_ty, _ep| }
+          scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -199,7 +277,31 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, true, ep)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :extended, aargs, ep, env) {|_ret_ty, _ep| }
+          # 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.mix_module(:before, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -268,23 +370,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, blk.outer_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
@@ -293,7 +397,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
@@ -302,7 +406,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
@@ -311,7 +415,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
@@ -444,43 +548,55 @@ module TypeProf
         ctn[Type.any, ep, env]
         return
       end
-      scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |member_ary_ty, ep|
-        next if member_ary_ty == Type.nil
-        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)
+      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_i_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      # TODO: keyword_init
-
-      meths = scratch.get_method(recv, false, :initialize)
-      recv = Type::Instance.new(recv)
-      meths.flat_map do |meth|
-        meth.do_send(recv, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
-          ctn[recv, ep, env]
+    def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
+      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
-    end
-
-    def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      # TODO: keyword_init
 
       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]
@@ -654,25 +770,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[: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[: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]
@@ -687,23 +804,31 @@ 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_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_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_module, :class_eval, Builtin.method(:object_module_eval))
+      scratch.set_custom_method(klass_module, :module_eval, Builtin.method(:object_module_eval))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))
@@ -718,10 +843,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