typeprof 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd38b5e501a5d4fbe4db1ad43015c44ab39dbfefc3f7638516faeb5bcafd21a9
-  data.tar.gz: 000f140ab750e4ddd57863851c21a830bfe470c0eb7be9e38442ca535f4ef041
+  metadata.gz: 1c3bf54ec6fee3b06397893d2f10f1fae8e7af82b8f1640a4ddd305c33922ff7
+  data.tar.gz: 944d40a75789b4805e53ca70e169fe68fcd4dbca7f24bc4ccc779964085e980d
 SHA512:
-  metadata.gz: '00924963d5f91c4609224615507fcfb240a140c8119bf76f24aa28973342e6b61c528fc579781690f9f0392bf0d125c8bdb70499525791603c111ed9251da931'
-  data.tar.gz: ee07e0636cd3e26271c468e1927e676a1b320ddefe13dc2412c254cac9aaeac7ca5db1936a26ccc477c2494473fde1d2bdde7a28bd1fa384c6995d7ae4d085ea
+  metadata.gz: 726cdbfcda694f189a96f3f35088cbcbd9a3064e79e3838f7758d7bc393bf8591c0559db1c17993f971f9ae2ee4ca3b4c09f5c0ef6d6675752b00b6948cdfe62
+  data.tar.gz: b2b7353855183df391d8bc78c247eb7de09c1b65b2753789eb1e1fb0208275d10fec6d2d95745f36771de30af5e32281476100a0654db6f7cf87c8e442b36a65

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.8.0)
-      rbs (>= 0.17.0)
+    typeprof (0.9.0)
+      rbs (>= 0.20.0)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
     docile (1.3.2)
     power_assert (1.2.0)
     rake (13.0.1)
-    rbs (0.18.1)
+    rbs (0.20.1)
     simplecov (0.20.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

data/lib/typeprof/analyzer.rb

@@ -34,6 +34,14 @@ module TypeProf
     end
 
     attr_reader :iseq, :cref, :mid
+
+    def source_location(pc)
+      if @iseq
+        @iseq.source_location(pc)
+      else
+        "<builtin>"
+      end
+    end
   end
 
   class TypedContext
@@ -45,6 +53,14 @@ module TypeProf
     end
 
     attr_reader :caller_ep, :mid
+
+    def source_location(_pc)
+      if @caller_ep
+        @caller_ep.source_location
+      else
+        "<typed-context:#{ @mid }>"
+      end
+    end
   end
 
   class ExecutionPoint
@@ -71,12 +87,7 @@ module TypeProf
     end
 
     def source_location
-      iseq = @ctx.iseq
-      if iseq
-        iseq.source_location(@pc)
-      else
-        "<builtin>"
-      end
+      @ctx.source_location(@pc)
     end
   end
 
@@ -91,7 +102,7 @@ module TypeProf
 
       return if recv_ty == :top #OK
       recv_ty.each_child_global do |ty|
-        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && ty != Type.any
+        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && !ty.is_a?(Type::Symbol) && ty != Type.any
       end
     end
 
@@ -298,8 +309,8 @@ module TypeProf
       attr_accessor :name, :klass_obj
 
       def include_module(mod, type_args, singleton, absolute_path)
-        module_type_args, _, absolute_paths = @modules[singleton].find {|m,| m == mod }
-        if module_type_args
+        mod_, module_type_args, absolute_paths = @modules[singleton].find {|m,| m == mod }
+        if mod_
           raise "inconsistent include/extend type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
         else
           absolute_paths = Utils::MutableSet.new
@@ -335,11 +346,14 @@ module TypeProf
         end
       end
 
-      def search_method(singleton, mid, &blk)
+      def search_method(singleton, mid, visited, &blk)
+        # Currently, circular inclusion of modules is allowed
+        return if visited[self]
+        visited[self] = true
         mthds = @methods[[singleton, mid]]
         yield mthds, @klass_obj, singleton if mthds
         @modules[singleton].each do |mod_def,|
-          mod_def.search_method(false, mid, &blk)
+          mod_def.search_method(false, mid, visited, &blk)
         end
       end
 
@@ -367,7 +381,7 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, type_args, singleton, absolute_path)
+    def include_module(including_mod, included_mod, type_args, singleton, caller_ep)
       return if included_mod == Type.any
 
       including_mod = @class_defs[including_mod.idx]
@@ -375,9 +389,9 @@ module TypeProf
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, type_args, singleton, absolute_path)
+            including_mod.include_module(included_mod, type_args, singleton, caller_ep ? caller_ep.ctx.iseq.absolute_path : nil)
           else
-            warn "including something that is not a module"
+            warn(caller_ep, "including something that is not a module")
           end
         end
       end
@@ -479,13 +493,13 @@ module TypeProf
       if klass.kind == :class
         while klass != :__root__
           class_def = @class_defs[klass.idx]
-          class_def.search_method(singleton, mid, &blk)
+          class_def.search_method(singleton, mid, {}, &blk)
           klass = klass.superclass
         end
       else
         # module
         class_def = @class_defs[klass.idx]
-        class_def.search_method(singleton, mid, &blk)
+        class_def.search_method(singleton, mid, {}, &blk)
       end
       if singleton
         search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
@@ -545,9 +559,7 @@ module TypeProf
     end
 
     def add_constant(klass, name, value, user_defined)
-      if klass == Type.any
-        self
-      else
+      if klass.is_a?(Type::Class)
         @class_defs[klass.idx].add_constant(name, value, user_defined)
       end
     end
@@ -613,6 +625,10 @@ module TypeProf
       @iseq_method_to_ctxs[iseq_mdef] << ctx
     end
 
+    def add_executed_iseq(iseq)
+      @executed_iseqs << iseq
+    end
+
     def add_callsite!(callee_ctx, caller_ep, caller_env, &ctn)
       @executed_iseqs << callee_ctx.iseq if callee_ctx.is_a?(Context)
 
@@ -672,7 +688,7 @@ module TypeProf
       def add_read!(site, ep, &ctn)
         entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new)
         entry.read_continuations[ep] = ctn
-        entry.absolute_paths << ep.ctx.iseq.absolute_path
+        entry.absolute_paths << ep.ctx.iseq.absolute_path if ep.ctx.is_a?(Context)
         ctn[entry.type, ep]
       end
 
@@ -731,6 +747,7 @@ module TypeProf
 
     def add_cvar_read!(klass, var, ep, &ctn)
       klass.each_child do |klass|
+        next unless klass.is_a?(Type::Class)
         class_def = @class_defs[klass.idx]
         next unless class_def
         class_def.cvars.add_read!(var, ep, &ctn)
@@ -739,6 +756,7 @@ module TypeProf
 
     def add_cvar_write!(klass, var, ty, ep)
       klass.each_child do |klass|
+        next unless klass.is_a?(Type::Class)
         class_def = @class_defs[klass.idx]
         next unless class_def
         class_def.cvars.add_write!(var, ty, ep, self)
@@ -870,7 +888,7 @@ module TypeProf
           @pending_execution.delete(iseq)
         end while @executed_iseqs.include?(iseq)
 
-        puts "DEBUG: trigger dummy execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
+        puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
 
         break if !iseq
         case kind
@@ -974,10 +992,14 @@ module TypeProf
 
     def pend_block_dummy_execution(blk, iseq, nep, nenv)
       @pending_execution[iseq] ||= [:block, [blk, {}]]
-      if @pending_execution[iseq][1][1][nep]
-        @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
+      if @pending_execution[iseq][0] == :block
+        if @pending_execution[iseq][1][1][nep]
+          @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
+        else
+          @pending_execution[iseq][1][1][nep] = nenv
+        end
       else
-        @pending_execution[iseq][1][1][nep] = nenv
+        # XXX: what to do?
       end
     end
 
@@ -1026,7 +1048,7 @@ module TypeProf
         block_start = iseq.fargs_format[:block_start]
 
         lead_tys = env.locals[0, lead_num].map {|ty| globalize_type(ty, env, ep) }
-        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : nil
+        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : []
         if rest_start # XXX:squash
           ty = globalize_type(env.locals[lead_num + opt.size - 1], env, ep)
           rest_ty = Type.bot
@@ -1197,11 +1219,11 @@ module TypeProf
             else # module
               superclass = nil
             end
-            if cbase == Type.any
-              klass = Type.any
-            else
+            if cbase.is_a?(Type::Class)
               klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
               add_superclass_type_args!(klass, superclass.type_params.map { Type.any }) if superclass
+            else
+              klass = Type.any
             end
           end
           singleton = false
@@ -1339,11 +1361,24 @@ module TypeProf
           return
         when :break
           tmp_ep = ep
-          tmp_ep = tmp_ep.outer while tmp_ep.ctx.iseq.type != :block
-          tmp_ep = tmp_ep.outer
-          nenv = @return_envs[tmp_ep].push(ty)
-          merge_env(tmp_ep.next, nenv)
-          # TODO: jump to ensure?
+          while true
+            if tmp_ep.ctx.iseq.type == :block
+              tmp_ep = tmp_ep.outer
+              nenv = @return_envs[tmp_ep].push(ty)
+              merge_env(tmp_ep.next, nenv)
+              break
+            end
+            _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc]&.find {|type,| type == :break }
+            if cont
+              nenv = @return_envs[tmp_ep]
+              nenv, = nenv.pop(nenv.stack.size - stack_depth)
+              nenv = nenv.push(ty)
+              tmp_ep = tmp_ep.jump(cont)
+              merge_env(tmp_ep, nenv)
+              break
+            end
+            tmp_ep = tmp_ep.outer
+          end
         when :next, :redo
           # begin; rescue; next; end
           tmp_ep = ep.outer
@@ -1585,7 +1620,7 @@ module TypeProf
           warn(ep, "already initialized constant #{ Type::Instance.new(cbase).screen_name(self) }::#{ name }")
         end
         ty.each_child do |ty|
-          if ty.is_a?(Type::Class) && ty.superclass == Type::Builtin[:struct]
+          if ty.is_a?(Type::Class) && cbase.is_a?(Type::Class) && ty.superclass == Type::Builtin[:struct]
             @class_defs[ty.idx].name = cbase_path(cbase) + [name]
           end
         end
@@ -1594,7 +1629,6 @@ module TypeProf
       when :getspecial
         key, type = operands
         if type == 0
-          raise NotImplementedError
           case key
           when 0 # VM_SVAR_LASTLINE
             env = env.push(Type.any) # or String | NilClass only?
@@ -1612,8 +1646,12 @@ module TypeProf
           return
         end
       when :setspecial
-        # flip-flop
-        raise NotImplementedError, "setspecial"
+        key, = operands
+        if key >= 2 # flip-flop
+          env, = env.pop(1)
+        else
+          raise "unknown setspecial key: #{ key }"
+        end
 
       when :dup
         env, (ty,) = env.pop(1)
@@ -1664,10 +1702,16 @@ module TypeProf
         env = env.push(Type.optional(sym_ty))
       when :checkmatch
         flag, = operands
+
+        # This flag means that the stack top is an array, and the check needs to be applied to find all elements
+        # However, currently TypeProf uses very conservative interpretation (all check returns both true and false),
+        # so we just ignore the flag now
         _array = flag & 4 != 0
+
         case flag & 3
-        when 1
-          raise NotImplementedError
+        when 1 # VM_CHECKMATCH_TYPE_WHEN
+          env, = env.pop(2)
+          env = env.push(Type.bool)
         when 2 # VM_CHECKMATCH_TYPE_CASE
           env, = env.pop(2)
           env = env.push(Type.bool)
@@ -1877,6 +1921,10 @@ module TypeProf
         rest_ty = aargs.last
         aargs = aargs[0..-2]
         if flag_args_kw_splat
+          # XXX: The types contained in ActualArguments are expected to be all local types.
+          # This "globalize_type" breaks the invariant, and violates the assertion of Union#globalize that asserts @elems be nil.
+          # To fix this issue fundamentally, ActualArguments should keep all arguments as-is (as like the VM does),
+          # and globalize some types on the on-demand bases.
           ty = globalize_type(rest_ty, env, ep)
           if ty.is_a?(Type::Array)
             _, (ty,) = ty.elems.take_last(1)
@@ -1909,6 +1957,10 @@ module TypeProf
         aargs = ActualArguments.new(aargs, rest_ty, kw_tys, blk_ty)
       elsif flag_args_kw_splat
         last = aargs.last
+        # XXX: The types contained in ActualArguments are expected to be all local types.
+        # This "globalize_type" breaks the invariant, and violates the assertion of Union#globalize that asserts @elems be nil.
+        # To fix this issue fundamentally, ActualArguments should keep all arguments as-is (as like the VM does),
+        # and globalize some types on the on-demand bases.
         ty = globalize_type(last, env, ep)
         case ty
         when Type::Hash
@@ -2003,10 +2055,10 @@ module TypeProf
 
     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)
+        recv = cref.klass
+        recv = Type::Instance.new(recv) unless ep.ctx.cref.singleton
         if typed_mdef
           mdef = ISeqMethodDef.new(iseq, cref, outer_ep, env.static_env.pub_meth)
           typed_mdef.each do |typed_mdef|
@@ -2021,9 +2073,9 @@ module TypeProf
               add_singleton_iseq_method(cref.klass, mid, iseq, cref, outer_ep, true)
             end
           end
-
-          pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
         end
+
+        pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, outer_ep)
       else
         # XXX: what to do?
       end
@@ -2069,7 +2121,7 @@ module TypeProf
           next unless @block_to_ctx[blk.block_body] # this occurs when screen_name is called before type-profiling finished (e.g., error message)
           @block_to_ctx[blk.block_body].each do |blk_ctx|
             if farg_tys
-              farg_tys = farg_tys.merge(@method_signatures[blk_ctx])
+              farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
             else
               farg_tys = @method_signatures[blk_ctx]
             end

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)

data/lib/typeprof/builtin.rb

@@ -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,10 @@ 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
 
@@ -159,10 +169,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.include_module(recv, arg, nil, false, ep)
         end
       end
       ctn[recv, ep, env]
@@ -174,10 +190,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, true, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, nil, true, ep)
         end
       end
       ctn[recv, ep, env]
@@ -202,13 +224,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 +244,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
@@ -245,7 +275,7 @@ module TypeProf
             blk = blk_ty.block_body
             case blk
             when ISeqBlock
-              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, ep)
+              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, blk.outer_ep)
             else
               # XXX: what to do?
             end
@@ -323,14 +353,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 +402,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 +413,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 +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
@@ -415,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.bot
+        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
@@ -491,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
@@ -505,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]
@@ -541,7 +597,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
@@ -597,6 +658,7 @@ module TypeProf
       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)
@@ -610,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]
@@ -624,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?))
@@ -641,6 +701,9 @@ module TypeProf
       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))