typeprof 0.6.0 → 0.9.1

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)
@@ -10,6 +11,10 @@ module TypeProf
       raise unless blk_ty
     end
 
+    def for_method_missing(mid)
+      ActualArguments.new([mid] + @lead_tys, @rest_ty, @kw_tys, @blk_ty)
+    end
+
     attr_reader :lead_tys, :rest_ty, :kw_tys, :blk_ty
 
     def globalize(caller_env, visited, depth)
@@ -54,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)
@@ -148,12 +154,14 @@ module TypeProf
               lead_tys = ty.elems.lead_tys
               rest_ty = ty.elems.rest_ty
             when Type::Union
-              other_elems = nil
-              ty.elems&.each do |(container_kind, base_type), elems|
-                if container_kind == Type::Array
-                  rest_ty = rest_ty ? rest_ty.union(elems.squash) : elems.squash
-                else
-                  other_elems = other_elems ? other_elems.union(elems) : elems
+              if ty.elems
+                other_elems = {}
+                ty.elems.each do |(container_kind, base_type), elems|
+                  if container_kind == Type::Array
+                    rest_ty = rest_ty ? rest_ty.union(elems.squash) : elems.squash
+                  else
+                    other_elems[[container_kind, base_type]] = elems
+                  end
                 end
               end
               lead_tys = [Type::Union.new(ty.types, other_elems)]

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)

data/lib/typeprof/builtin.rb

@@ -33,10 +33,10 @@ module TypeProf
       h2 = aargs.lead_tys[1]
       elems = nil
       h1.each_child do |h1|
-        if h1.is_a?(Type::LocalHash)
+        if h1.is_a?(Type::Local) && h1.kind == Type::Hash
           h1_elems = scratch.get_container_elem_types(env, ep, h1.id)
           h2.each_child do |h2|
-            if h2.is_a?(Type::LocalHash)
+            if h2.is_a?(Type::Local) && h2.kind == Type::Hash
               h2_elems = scratch.get_container_elem_types(env, ep, h2.id)
               elems0 = h1_elems.union(h2_elems)
               if elems
@@ -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)
@@ -143,26 +151,34 @@ module TypeProf
 
     def object_instance_eval(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size >= 1
-        scratch.warn(ep, "instance_eval with arguments are ignored")
+        scratch.warn(ep, "instance_eval with arguments is ignored")
         ctn[Type.any, ep, env]
         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 module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size != 1
-        scratch.warn(ep, "Module#include without an argument are ignored")
+        scratch.warn(ep, "Module#include 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, false, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, nil, false, ep)
         end
       end
       ctn[recv, ep, env]
@@ -170,14 +186,20 @@ module TypeProf
 
     def module_extend(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size != 1
-        scratch.warn(ep, "Module#extend without an argument are ignored")
+        scratch.warn(ep, "Module#extend 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.include_module(recv, arg, nil, true, ep)
         end
       end
       ctn[recv, ep, env]
@@ -198,6 +220,75 @@ module TypeProf
       end
     end
 
+    def module_public(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.empty?
+        ctn[recv, ep, env.method_public_set(true)]
+      else
+        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
+    end
+
+    def module_private(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.empty?
+        ctn[recv, ep, env.method_public_set(false)]
+      else
+        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
+    end
+
+    def module_define_method(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#define with #{ aargs.lead_tys.size } argument is ignored")
+        ctn[Type.any, ep, env]
+        return
+      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)
+            else
+              # XXX: what to do?
+            end
+          else
+            # XXX: what to do?
+          end
+        end
+      else
+        # XXX: what to do?
+      end
+      ctn[Type.any, ep, env]
+    end
+
     def module_attr_accessor(recv, mid, aargs, ep, env, scratch, &ctn)
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_accessor", aarg, ep, scratch) or next
@@ -233,21 +324,16 @@ module TypeProf
     end
 
     def array_aref(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       case aargs.lead_tys.size
       when 1
         idx = aargs.lead_tys.first
         if idx.is_a?(Type::Literal)
           idx = idx.lit
-          if idx.is_a?(Range)
-            ty = scratch.get_array_elem_type(env, ep, recv.id)
-            base_ty = Type::Instance.new(Type::Builtin[:ary])
-            ret_ty = Type::Array.new(Type::Array::Elements.new([], ty), base_ty)
-            ctn[ret_ty, ep, env]
-            return
-          end
-          idx = nil if !idx.is_a?(Integer)
+          idx = nil if !idx.is_a?(Integer) && !idx.is_a?(Range)
+        elsif idx == Type::Instance.new(Type::Builtin[:range])
+          idx = (nil..nil)
         else
           idx = nil
         end
@@ -264,17 +350,22 @@ module TypeProf
     end
 
     def array_aset(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      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
@@ -289,7 +380,7 @@ module TypeProf
     end
 
     def array_pop(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       if aargs.lead_tys.size != 0
         ctn[Type.any, ep, env]
@@ -301,7 +392,7 @@ module TypeProf
     end
 
     def hash_aref(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalHash)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
 
       if aargs.lead_tys.size != 1
         ctn[Type.any, ep, env]
@@ -309,8 +400,9 @@ module TypeProf
       end
       idx = aargs.lead_tys.first
       recv.each_child do |recv|
-        if recv.is_a?(Type::LocalHash)
+        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
@@ -319,15 +411,19 @@ module TypeProf
     end
 
     def hash_aset(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalHash)
+      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)
       ty = aargs.lead_tys.last
 
-      unless recv.is_a?(Type::LocalHash)
+      unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
         # to ignore: class OptionMap < Hash
         return ctn[ty, ep, env]
       end
@@ -340,18 +436,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
@@ -359,15 +444,24 @@ 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)
+      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)
         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[Type::Instance.new(recv), ep, env]
+          ctn[recv, ep, env]
         end
       end
     end
@@ -435,11 +529,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
@@ -449,22 +552,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]
@@ -484,6 +596,36 @@ module TypeProf
       ctn[result, ep, env]
     end
 
+    def kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+      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
+
+        action, arg = Builtin.file_require(feature, scratch)
+        case action
+        when :do
+          Builtin.file_load(arg, ep, env, scratch, &ctn)
+        when :done
+        when :error
+          scratch.warn(ep, arg)
+        end
+        ctn[Type.nil, ep, env]
+      else
+        scratch.warn(ep, "autoload target cannot be identified statically")
+        ctn[Type.nil, ep, env]
+      end
+    end
+
+    def module_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+      kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+    end
+
     def kernel_Array(recv, mid, aargs, ep, env, scratch, &ctn)
       raise NotImplementedError if aargs.lead_tys.size != 1
       ty = aargs.lead_tys.first
@@ -502,8 +644,8 @@ module TypeProf
     end
 
     def self.setup_initial_global_env(scratch)
-      klass_basic_obj = scratch.new_class(nil, :BasicObject, [], :__root__, nil, nil) # cbase, name, superclass
-      klass_obj = scratch.new_class(nil, :Object, [], klass_basic_obj, [], nil)
+      klass_basic_obj = scratch.new_class(nil, :BasicObject, [], :__root__, nil) # cbase, name, superclass
+      klass_obj = scratch.new_class(nil, :Object, [], klass_basic_obj, nil)
       scratch.add_constant(klass_obj, :Object, klass_obj, nil)
       scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj, nil)
 
@@ -512,10 +654,11 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, [], nil)
+      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)
@@ -529,6 +672,7 @@ module TypeProf
       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)
 
       klass_vmcore = Type::Builtin[:vmcore]
       klass_ary    = Type::Builtin[:ary]
@@ -543,9 +687,6 @@ 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, :is_a?, Builtin.method(:object_is_a?))
       scratch.set_custom_method(klass_obj, :respond_to?, Builtin.method(:object_respond_to?))
@@ -557,6 +698,12 @@ module TypeProf
       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, :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))
@@ -574,6 +721,11 @@ module TypeProf
       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_module, :autoload, Builtin.method(:module_autoload))
+
+      # remove BasicObject#method_missing
+      scratch.set_method(klass_basic_obj, :method_missing, false, nil)
 
       # ENV: Hash[String, String]
       str_ty = Type::Instance.new(Type::Builtin[:str])