typeprof 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dedfe8da717afcf508820efe445a790336ab877156d5b2de3683ab5043c18ab
-  data.tar.gz: 345fa1163af50a1b01fef26a83a835bfd7813453c6132ebb1036fe8178dd9757
+  metadata.gz: e8ecd99e5448a244b11714710dfbb5fd3f36274c5f72fa97da034059018fc32f
+  data.tar.gz: ed322065cf15d08f7bb50105cce19d74d923d4d7af7f94a563668788849d636d
 SHA512:
-  metadata.gz: 48972d2ab935ff782a0651eda48afa301531d5c5fff4f1a9ba17d29c54323b127fc3013c29863c21b26d77e81230c2e0318d58d3cde680c57b611c5a77a1214b
-  data.tar.gz: dc29d8282f165f9ddaabecf97f4eb81aaaa43c5defe1d63d083ef1147c2c0e6d2def961fa07f339587902d8524ee66940da742a5b30cd48dcccdcd94262883a8
+  metadata.gz: 528dcf83aa2ceec79ea602f3505eb48230baf87bae8409212f8f152b45e308c66490ff5d10a9153698870e02b0ee5f031ce81cbb48a4460187992269708957ef
+  data.tar.gz: a03594cb0b6a88ba905dc860ba9de64beb82a6cb1ebc562aad94cf20ecf14e36534bbf8a29a0b629189c62c32c26437104acb4387159c17bb222c708614cc303

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.6.1)
+    typeprof (0.7.0)
       rbs (>= 0.17.0)
 
 GEM
@@ -17,7 +17,7 @@ GEM
       simplecov-html (~> 0.11)
     simplecov-html (0.12.3)
     stackprof (0.2.16)
-    test-unit (3.3.6)
+    test-unit (3.3.7)
       power_assert
 
 PLATFORMS

data/doc/doc.ja.md

@@ -35,10 +35,9 @@ $ typeprof sig/app.rbs app.rb -o sig/app.gen.rbs
 * `--exclude-dir DIR`: `DIR`以下のファイルの解析結果を出力から省略する。後に指定されているほうが優先される（`--include-dir foo --exclude-dir foo/bar`の場合う、foo/bar/baz.rbの結果は出力されず、foo/baz.rbの結果は出力される）。
 * `--include-dir DIR`: `DIR`以下のファイルの解析結果を出力に含める。後に指定されているほうが優先される（`--exclude-dir foo --include-dir foo/bar`の場合、
 foo/bar/baz.rbの結果は出力されるが、foo/baz.rbの結果は出力されない）。
-* `-fshow-errors`: 実行中に見つけたバグの可能性を出力します（多くの場合、大量のfalse positiveが出ます）。
-* `-fpedantic-output`: デフォルトでは`A | untyped`と推定されたところを単に`A`と出力しますが、より生の出力、つまり`A | untyped`と出力します。
-* `-fshow-container-raw-elements`: （後で書く）
-* `-ftype-depth-limit=NUM`: （後で書く）
+* `--show-errors`: 実行中に見つけたバグの可能性を出力します（多くの場合、大量のfalse positiveが出ます）。
+* `--show-untyped`: デフォルトでは`A | untyped`と推定されたところを単に`A`と出力しますが、より生の出力、つまり`A | untyped`と出力します。
+* `--type-depth-limit=NUM`: （後で書く）
 
 ## TypeProfとは
 

data/doc/doc.md

@@ -34,10 +34,9 @@ Here is a list of currently avaiable options:
 * `-r GEMNAME`: Load the RBS files of `GEMNAME`
 * `--exclude-dir DIR`: Omit the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--include-dir foo --exclude-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is omitted, but foo/baz.rb is shown.)
 * `--include-dir DIR`: Show the result of files that are placed under the directory `DIR`.  If there are some directory specifications, the latter one is stronger.  (Assuming that `--exclude-dir foo --include-dir foo/bar` is specified, the analysis result of foo/bar/baz.rb is shown, but foo/baz.rb is omitted.)
-* `-fshow-errors`: Prints out possible bugs found during execution (often a lot of false positives).
-* `-fpedantic-output`: When TypeProf inferred a type `A | untyped`, it simply outputs `A` by default. But this option forces it to output `A | untyped`.
-* `-fshow-container-raw-elements`: (undocumented yet)
-* `-ftype-depth-limit=NUM`: (undocumented yet)
+* `--show-errors`: Prints out possible bugs found during execution (often a lot of false positives).
+* `--show-untyped`: When TypeProf infers a type `A | untyped`, it simply outputs `A` by default. But this option forces to output `A | untyped`.
+* `--type-depth-limit=NUM`: (undocumented yet)
 
 ## What is a TypeProf?
 

data/lib/typeprof/analyzer.rb

@@ -185,18 +185,11 @@ module TypeProf
       Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
     end
 
-    def deploy_type(klass, alloc_site, elems, base_ty)
-      local_ty = klass.new(alloc_site, base_ty)
-      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ alloc_site => elems }))
-      nenv = Env.new(@static_env, @locals, @stack, type_params)
-      return nenv, local_ty
-    end
-
     def get_container_elem_types(id)
       @type_params.internal_hash[id]
     end
 
-    def update_container_elem_types(id, elems)
+    def deploy_type(id, elems)
       type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ id => elems }))
       Env.new(@static_env, @locals, @stack, type_params)
     end
@@ -320,9 +313,9 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def generate_substitution(singleton, mid, mthd, subst, &blk)
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
         mthds = @methods[[singleton, mid]]
-        yield subst if mthds&.include?(mthd)
+        yield subst, direct if mthds&.include?(mthd)
         @modules[singleton].each do |mod_def, type_args,|
           if mod_def.klass_obj.type_params && type_args
             subst2 = {}
@@ -330,7 +323,7 @@ module TypeProf
               tyvar = Type::Var.new(tyvar)
               subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
             end
-            mod_def.generate_substitution(false, mid, mthd, subst2, &blk)
+            mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
           end
         end
       end
@@ -358,8 +351,12 @@ module TypeProf
       end
 
       def set_method(mid, singleton, mdef)
-        @methods[[singleton, mid]] = Utils::MutableSet.new
-        @methods[[singleton, mid]] << mdef
+        if mdef
+          @methods[[singleton, mid]] = Utils::MutableSet.new
+          @methods[[singleton, mid]] << mdef
+        else
+          @methods.delete([singleton, mid])
+        end
       end
     end
 
@@ -410,7 +407,7 @@ module TypeProf
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
       @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, [], name)
+      klass = Type::Class.new(:class, idx, [], superclass, [Type.any], name)
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -440,11 +437,13 @@ module TypeProf
       end
     end
 
-    def generate_substitution(klass, singleton, mid, mthd, subst, &blk)
+    def adjust_substitution(klass, singleton, mid, mthd, subst, &blk)
+      direct = true
       if klass.kind == :class
         while klass != :__root__
           class_def = @class_defs[klass.idx]
-          class_def.generate_substitution(singleton, mid, mthd, subst, &blk)
+          class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+          direct = false
           if klass.superclass && klass.superclass_type_args
             subst2 = {}
             klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
@@ -458,7 +457,7 @@ module TypeProf
       else
         # module
         class_def = @class_defs[klass.idx]
-        class_def.generate_substitution(singleton, mid, mthd, subst, &blk)
+        class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
       end
     end
 
@@ -564,12 +563,12 @@ module TypeProf
       end
     end
 
-    def add_iseq_method(klass, mid, iseq, cref)
-      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref))
+    def add_iseq_method(klass, mid, iseq, cref, outer_ep)
+      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref, outer_ep))
     end
 
-    def add_singleton_iseq_method(klass, mid, iseq, cref)
-      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref))
+    def add_singleton_iseq_method(klass, mid, iseq, cref, outer_ep)
+      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref, outer_ep))
     end
 
     def set_custom_method(klass, mid, impl)
@@ -778,7 +777,7 @@ module TypeProf
         merge_return_env(tmp_ep) do |menv|
           elems = menv.get_container_elem_types(id)
           elems = yield elems
-          menv = menv.update_container_elem_types(id, elems)
+          menv = menv.deploy_type(id, elems)
           gid = @alloc_site_to_global_id[id]
           if gid
             ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
@@ -790,7 +789,7 @@ module TypeProf
       else
         elems = env.get_container_elem_types(id)
         elems = yield elems
-        env = env.update_container_elem_types(id, elems)
+        env = env.deploy_type(id, elems)
         gid = @alloc_site_to_global_id[id]
         if gid
           ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
@@ -831,11 +830,11 @@ module TypeProf
           ep = @worklist.deletemin
 
           iter_counter += 1
-          if Config.verbose >= 1
+          if Config.options[:show_indicator]
             tick2 = Time.now
             if tick2 - tick >= 1
               tick = tick2
-              $stderr << "\rType Profiling... (%d steps @ %s)\e[K" % [iter_counter, ep.source_location]
+              $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
               $stderr.flush
             end
           end
@@ -851,9 +850,7 @@ module TypeProf
 
         break if @terminated
 
-        # XXX: it would be good to provide no-dummy-execution mode.
-        # It should work as a bit smarter "rbs prototype rb";
-        # show all method definitions as "untyped" arguments and return values
+        break unless Config.options[:stub_execution]
 
         begin
           iseq, (kind, dummy_continuation) = @pending_execution.first
@@ -878,7 +875,7 @@ module TypeProf
           end
         end
       end
-      $stderr.print "\r\e[K" if Config.verbose >= 1
+      $stderr.print "\r\e[K" if Config.options[:show_indicator]
 
       stat_eps
     end
@@ -919,9 +916,9 @@ module TypeProf
       end
     end
 
-    def pend_method_execution(iseq, meth, recv, mid, cref)
+    def pend_method_execution(iseq, meth, recv, mid, cref, ep)
       ctx = Context.new(iseq, cref, mid)
-      ep = ExecutionPoint.new(ctx, 0, nil)
+      ep = ExecutionPoint.new(ctx, 0, ep)
       locals = [Type.nil] * iseq.locals.size
 
       fargs_format = iseq.fargs_format
@@ -958,7 +955,9 @@ module TypeProf
 
       env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
 
-      @pending_execution[iseq] ||= [:method, [meth, ep, env]]
+      if !@pending_execution[iseq] || @pending_execution[iseq][0] == :block
+        @pending_execution[iseq] = [:method, [meth, ep, env]]
+      end
     end
 
     def pend_block_dummy_execution(blk, iseq, nep, nenv)
@@ -975,7 +974,7 @@ module TypeProf
         alloc_site = AllocationSite.new(ep)
         nenv, ty = localize_type(ty, env, ep, alloc_site)
         case ty
-        when Type::LocalCell, Type::LocalArray, Type::LocalHash
+        when Type::Local
           @alloc_site_to_global_id[ty.id] = [recv, var] # need overwrite check??
         end
         yield ty, nenv
@@ -1141,31 +1140,7 @@ module TypeProf
 
       when :definemethod
         mid, iseq = operands
-        cref = ep.ctx.cref
-        recv = env.static_env.recv_ty
-        if cref.klass.is_a?(Type::Class)
-          typed_mdef = check_typed_method(cref.klass, mid, ep.ctx.cref.singleton)
-          recv = Type::Instance.new(recv) if recv.is_a?(Type::Class)
-          if typed_mdef
-            mdef = ISeqMethodDef.new(iseq, cref)
-            typed_mdef.each do |typed_mdef|
-              typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
-            end
-          else
-            if ep.ctx.cref.singleton
-              meth = add_singleton_iseq_method(cref.klass, mid, iseq, cref)
-            else
-              meth = add_iseq_method(cref.klass, mid, iseq, cref)
-              if env.static_env.mod_func
-                add_singleton_iseq_method(cref.klass, mid, iseq, cref)
-              end
-            end
-
-            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref)
-          end
-        else
-          # XXX: what to do?
-        end
+        do_define_iseq_method(ep, env, mid, iseq, nil)
 
       when :definesmethod
         mid, iseq = operands
@@ -1173,8 +1148,8 @@ module TypeProf
         cref = ep.ctx.cref
         recv.each_child do |recv|
           if recv.is_a?(Type::Class)
-            meth = add_singleton_iseq_method(recv, mid, iseq, cref)
-            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref)
+            meth = add_singleton_iseq_method(recv, mid, iseq, cref, nil)
+            pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, nil)
           else
             recv = Type.any # XXX: what to do?
           end
@@ -1549,9 +1524,7 @@ module TypeProf
         ret_ty.each_child do |ret_ty|
           flow_env = env.local_update(-var_idx+2, ret_ty)
           ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::Symbol)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalCell)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalArray)
-          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::LocalHash)
+          ret_ty = ret_ty.base_type if ret_ty.is_a?(Type::Local)
           if ret_ty.is_a?(Type::Instance)
             if ret_ty.klass == pattern_ty # XXX: inheritance
               merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
@@ -1717,9 +1690,13 @@ module TypeProf
         from_head = flag & 2 == 0
         ary.each_child do |ary|
           case ary
-          when Type::LocalArray
-            elems = get_container_elem_types(env, ep, ary.id)
-            elems ||= Type::Array::Elements.new([], Type.any) # XXX
+          when Type::Local
+            if ary.kind == Type::Array
+              elems = get_container_elem_types(env, ep, ary.id)
+              elems ||= Type::Array::Elements.new([], Type.any) # XXX
+            else
+              elems = Type::Array::Elements.new([], Type.any) # XXX
+            end
             do_expand_array(ep, env, elems, num, splat, from_head)
           when Type::Any
             nnum = num
@@ -1739,9 +1716,9 @@ module TypeProf
         return
       when :concatarray
         env, (ary1, ary2) = env.pop(2)
-        if ary1.is_a?(Type::LocalArray)
+        if ary1.is_a?(Type::Local) && ary1.kind == Type::Array
           elems1 = get_container_elem_types(env, ep, ary1.id)
-          if ary2.is_a?(Type::LocalArray)
+          if ary2.is_a?(Type::Local) && ary2.kind == Type::Array
             elems2 = get_container_elem_types(env, ep, ary2.id)
             elems = Type::Array::Elements.new([], elems1.squash.union(elems2.squash))
             env = update_container_elem_types(env, ep, ary1.id, ary1.base_type) { elems }
@@ -1973,21 +1950,31 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, ep, env, &ctn)
-      klass, singleton = recv.method_dispatch_info
-      meths = get_method(klass, singleton, mid) if klass
-      if meths
-        meths.each do |meth|
-          meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
-        end
+      case recv
+      when Type::Void
+        error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+        ctn[Type.any, ep, env]
+      when Type::Any
+        ctn[Type.any, ep, env]
       else
-        case recv
-        when Type::Void
-          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-        when Type::Any
+        klass, singleton = recv.method_dispatch_info
+        meths = get_method(klass, singleton, mid) if klass
+        if meths
+          meths.each do |meth|
+            meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
+          end
         else
-          error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+          meths = get_method(klass, singleton, :method_missing) if klass
+          if meths
+            aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
+            meths.each do |meth|
+              meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+            end
+          else
+            error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+            ctn[Type.any, ep, env]
+          end
         end
-        ctn[Type.any, ep, env]
       end
     end
 
@@ -2002,6 +1989,34 @@ module TypeProf
       end
     end
 
+    def do_define_iseq_method(ep, env, mid, iseq, outer_ep)
+      cref = ep.ctx.cref
+      recv = env.static_env.recv_ty
+      if cref.klass.is_a?(Type::Class)
+        typed_mdef = check_typed_method(cref.klass, mid, ep.ctx.cref.singleton)
+        recv = Type::Instance.new(recv) if recv.is_a?(Type::Class)
+        if typed_mdef
+          mdef = ISeqMethodDef.new(iseq, cref, outer_ep)
+          typed_mdef.each do |typed_mdef|
+            typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
+          end
+        else
+          if ep.ctx.cref.singleton
+            meth = add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep)
+          else
+            meth = add_iseq_method(cref.klass, mid, iseq, cref, outer_ep)
+            if env.static_env.mod_func
+              add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep)
+            end
+          end
+
+          pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
+        end
+      else
+        # XXX: what to do?
+      end
+    end
+
     def show_block_signature(blks)
       bsig = nil
       ret_ty = Type.bot

data/lib/typeprof/arguments.rb

@@ -10,6 +10,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)
@@ -148,12 +152,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/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
@@ -143,7 +143,7 @@ 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
@@ -155,7 +155,7 @@ module TypeProf
 
     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
@@ -170,7 +170,7 @@ 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
@@ -198,6 +198,35 @@ module TypeProf
       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, 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 +262,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,7 +288,7 @@ 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
         #raise NotImplementedError # XXX
@@ -289,7 +313,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 +325,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,7 +333,7 @@ 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)
         else
           ty = Type.any
@@ -319,7 +343,7 @@ 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
 
@@ -327,7 +351,7 @@ module TypeProf
       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
@@ -484,6 +508,31 @@ module TypeProf
       ctn[result, ep, env]
     end
 
+    def kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+      raise NotImplementedError if aargs.lead_tys.size != 2
+      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
@@ -557,6 +606,7 @@ 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, :define_method, Builtin.method(:module_define_method))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))
@@ -574,6 +624,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])