typeprof 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93a881a8e59226faae21acac435131d5961c85ab6c95192ae1261329a87fb6e1
-  data.tar.gz: 8165e47acb1e8d9770922b2ac10487d18ff1b4fd1efa5d4ab8f6f0b11aa15433
+  metadata.gz: 8d68099e4f5d60a45f949d6bfc3a47e8b7d3b7ba66a0794f25f5fe61628de1d1
+  data.tar.gz: 22792d1acb9b16a4150f1afbaf29d59987bf29772908b23075e6668df81a4309
 SHA512:
-  metadata.gz: 43d0bc36fa68827aed7026cc7a52ca37b49d2c042bbaa32bffc9773afad296b81e27b5b4f97b31f24ff4030269f215034568175cae2c4a14bdc4bad8b502172f
-  data.tar.gz: 898d79a93ceae32f71b1c0fe0b9f2aa6a90477fbee58a582da91fe5e6f4e521062cb99549f8ae709d1f26f854a4b2765cdd455282fcdfa0ab9918c9015647ec9
+  metadata.gz: 42faa4e3b5c64fd5976e66067bf13339c530785914caad77bc0a405939bc914e9adf78bfbd0aea57a829cb21aed3c6dfc09f8f57def85b09312facd82d33b5a9
+  data.tar.gz: bc6f115fbf1d5292286f04f09d745cfb0c13688a71fdae730d0cfdd903ad8f9f3f9019e532c37b4cf23fe41f39c9a1683f92f28af68716ddf7e625a0efca33f8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.9.2)
+    typeprof (0.10.0)
       rbs (>= 0.20.1)
 
 GEM
@@ -24,6 +24,7 @@ GEM
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   coverage-helpers
@@ -35,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.2.0.rc.1
+   2.2.1

data/lib/typeprof/analyzer.rb

@@ -117,30 +117,6 @@ module TypeProf
     end
   end
 
-  class TopStaticEnv
-    include Utils::StructuralEquality
-
-    def recv_ty
-      Type.bot
-    end
-
-    def blk_ty
-      Type.nil
-    end
-
-    def mod_func
-      false
-    end
-
-    def pub_meth
-      true
-    end
-
-    def merge(other)
-      raise unless other.is_a?(TopStaticEnv)
-    end
-  end
-
   class Env
     include Utils::StructuralEquality
 
@@ -246,6 +222,11 @@ module TypeProf
       Env.new(senv, @locals, @stack, @type_params)
     end
 
+    def replace_blk_ty(ty)
+      senv = StaticEnv.new(@static_env.recv_ty, ty, @static_env.mod_func, @static_env.pub_meth)
+      Env.new(senv, @locals, @stack, @type_params)
+    end
+
     def inspect
       "Env[#{ @static_env.inspect }, locals:#{ @locals.inspect }, stack:#{ @stack.inspect }, type_params:#{ (@type_params&.internal_hash).inspect }]"
     end
@@ -319,7 +300,10 @@ module TypeProf
       def initialize(kind, name, absolute_path)
         raise unless name.is_a?(Array)
         @kind = kind
-        @modules = { true => [], false => [] }
+        @modules = {
+          :before => { true => [], false => [] }, # before = include/extend
+          :after  => { true => [], false => [] }, # after = prepend
+        }
         @name = name
         @consts = {}
         @methods = {}
@@ -332,13 +316,13 @@ module TypeProf
       attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, type_args, singleton, absolute_path)
-        mod_, module_type_args, absolute_paths = @modules[singleton].find {|m,| m == mod }
+      def mix_module(kind, mod, type_args, singleton, absolute_path)
+        mod_, module_type_args, absolute_paths = @modules[kind][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
+          raise "inconsistent #{ kind == :after ? "include/extend" : "prepend" } type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
         else
           absolute_paths = Utils::MutableSet.new
-          @modules[singleton].unshift([mod, type_args, absolute_paths])
+          @modules[kind][singleton].unshift([mod, type_args, absolute_paths])
         end
         absolute_paths << absolute_path
       end
@@ -355,10 +339,8 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
-        mthds = @methods[[singleton, mid]]
-        yield subst, direct if mthds&.include?(mthd)
-        @modules[singleton].each do |mod_def, type_args,|
+      def adjust_substitution_for_module(mods, mid, mthd, subst, &blk)
+        mods.each do |mod_def, type_args,|
           if mod_def.klass_obj.type_params && type_args
             subst2 = {}
             mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
@@ -370,13 +352,28 @@ module TypeProf
         end
       end
 
+      def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
+        adjust_substitution_for_module(@modules[:before][singleton], mid, mthd, subst, &blk)
+
+        mthds = @methods[[singleton, mid]]
+        yield subst, direct if mthds&.include?(mthd)
+
+        adjust_substitution_for_module(@modules[:after][singleton], mid, mthd, subst, &blk)
+      end
+
       def search_method(singleton, mid, visited, &blk)
         # Currently, circular inclusion of modules is allowed
         return if visited[self]
         visited[self] = true
+
+        @modules[:before][singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, visited, &blk)
+        end
+
         mthds = @methods[[singleton, mid]]
         yield mthds, @klass_obj, singleton if mthds
-        @modules[singleton].each do |mod_def,|
+
+        @modules[:after][singleton].each do |mod_def,|
           mod_def.search_method(false, mid, visited, &blk)
         end
       end
@@ -405,17 +402,17 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, type_args, singleton, caller_ep)
-      return if included_mod == Type.any
+    def mix_module(kind, mixing_mod, mixed_mod, type_args, singleton, caller_ep)
+      return if mixed_mod == Type.any
 
-      including_mod = @class_defs[including_mod.idx]
-      included_mod.each_child do |included_mod|
-        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, caller_ep ? caller_ep.ctx.iseq.absolute_path : nil)
+      mixing_mod = @class_defs[mixing_mod.idx]
+      mixed_mod.each_child do |mixed_mod|
+        if mixed_mod.is_a?(Type::Class)
+          mixed_mod = @class_defs[mixed_mod.idx]
+          if mixed_mod && mixed_mod.kind == :module
+            mixing_mod.mix_module(kind, mixed_mod, type_args, singleton, caller_ep ? caller_ep.ctx.iseq.absolute_path : nil)
           else
-            warn(caller_ep, "including something that is not a module")
+            warn(caller_ep, "attempted to #{ kind == :after ? "include/extend" : "prepend" } non-module; ignored")
           end
         end
       end
@@ -602,12 +599,12 @@ module TypeProf
       mdef
     end
 
-    def add_attr_method(klass, absolute_path, mid, ivar, kind)
+    def add_attr_method(klass, mid, ivar, kind, pub_meth, ep)
       if kind == :reader || kind == :accessor
-        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, absolute_path))
+        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, pub_meth, ep))
       end
       if kind == :writer || kind == :accessor
-        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, absolute_path))
+        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, pub_meth, ep))
       end
     end
 
@@ -619,22 +616,22 @@ module TypeProf
       add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
     end
 
-    def set_custom_method(klass, mid, impl)
-      set_method(klass, mid, false, CustomMethodDef.new(impl))
+    def set_custom_method(klass, mid, impl, pub_meth = true)
+      set_method(klass, mid, false, CustomMethodDef.new(impl, pub_meth))
     end
 
-    def set_singleton_custom_method(klass, mid, impl)
-      set_method(klass, mid, true, CustomMethodDef.new(impl))
+    def set_singleton_custom_method(klass, mid, impl, pub_meth = true)
+      set_method(klass, mid, true, CustomMethodDef.new(impl, pub_meth))
     end
 
-    def alias_method(klass, singleton, new, old)
+    def alias_method(klass, singleton, alias_mid, orig_mid, ep)
       if klass == Type.any
         self
       else
-        mdefs = get_method(klass, singleton, old)
+        mdefs = get_method(klass, singleton, orig_mid)
         if mdefs
           mdefs.each do |mdef|
-            @class_defs[klass.idx].add_method(new, singleton, mdef)
+            @class_defs[klass.idx].add_method(alias_mid, singleton, AliasMethodDef.new(orig_mid, mdef, ep))
           end
         end
       end
@@ -723,7 +720,7 @@ module TypeProf
         if ep
           if entry.rbs_declared
             unless Type.match?(ty, entry.type)
-              scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
+              scratch.warn(ep, "inconsistent assignment to RBS-declared variable")
               return
             end
           end
@@ -1076,7 +1073,7 @@ module TypeProf
         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) } : []
         if rest_start # XXX:squash
-          ty = globalize_type(env.locals[lead_num + opt.size - 1], env, ep)
+          ty = globalize_type(env.locals[rest_start], env, ep)
           rest_ty = Type.bot
           ty.each_child_global do |ty|
             if ty.is_a?(Type::Array)
@@ -1111,6 +1108,7 @@ module TypeProf
           end
         end
         kw_rest_ty = globalize_type(env.locals[kw_rest], env, ep) if kw_rest
+        kw_rest_ty = nil if kw_rest_ty == Type.nil
         if block_start
           blk_ty = globalize_type(env.locals[block_start], env, ep)
         elsif iseq.type == :method
@@ -1290,7 +1288,7 @@ module TypeProf
           end
         end
         return
-      when :send_branch
+      when :getlocal_send_branch
         getlocal_operands, send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
@@ -1318,6 +1316,31 @@ module TypeProf
           end
         end
         return
+      when :send_branch
+        send_operands, branch_operands = operands
+        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
+        recvs = Type.any if recvs == Type.bot
+        recvs.each_child do |recv|
+          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
+            env, ret_ty, = localize_type(ret_ty, env, ep)
+
+            branchtype, target, = branch_operands
+            # branchtype: :if or :unless or :nil
+            ep_then = ep.next
+            ep_else = ep.jump(target)
+
+            case ret_ty
+            when Type::Instance.new(Type::Builtin[:true])
+              merge_env(branchtype == :if ? ep_else : ep_then, env)
+            when Type::Instance.new(Type::Builtin[:false])
+              merge_env(branchtype == :if ? ep_then : ep_else, env)
+            else
+              merge_env(ep_then, env)
+              merge_env(ep_else, env)
+            end
+          end
+        end
+        return
       when :invokeblock
         env, recvs, mid, aargs = setup_actual_arguments(:block, operands, ep, env)
         blk = env.static_env.blk_ty
@@ -2130,7 +2153,7 @@ module TypeProf
 
       bsig ||= BlockSignature.new([], [], nil, Type.nil)
 
-      bsig = bsig.screen_name(self)#, block: true)
+      bsig = bsig.screen_name(nil, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
@@ -2157,7 +2180,7 @@ module TypeProf
         end
       end
 
-      farg_tys = farg_tys ? farg_tys.screen_name(self) : "(unknown)"
+      farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
@@ -2169,7 +2192,7 @@ module TypeProf
       farg_tys = @method_signatures[ctx]
       ret_ty = @return_values[ctx] || Type.bot
 
-      farg_tys = farg_tys.screen_name(self)
+      farg_tys = farg_tys.screen_name(ctx.iseq, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
       "#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }"

data/lib/typeprof/block.rb

@@ -137,4 +137,38 @@ module TypeProf
       end
     end
   end
+
+  class CustomBlock < Block
+    def initialize(caller_ep, mid, &blk)
+      @caller_ep = caller_ep
+      @mid = mid
+      @blk = blk
+    end
+
+    def inspect
+      "#<CustomBlock>"
+    end
+
+    def consistent?(other)
+      true # XXX
+    end
+
+    def substitute(_subst, _depth)
+      self
+    end
+
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+      aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
+
+      dummy_ctx = TypedContext.new(@caller_ep, @mid)
+
+      scratch.add_block_signature!(self, aargs.to_block_signature)
+      scratch.add_block_to_ctx!(self, dummy_ctx)
+
+      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty) do |ret_ty, ep, env|
+        scratch.add_return_value!(dummy_ctx, ret_ty)
+        ctn[ret_ty, ep, env]
+      end
+    end
+  end
 end

data/lib/typeprof/builtin.rb

@@ -19,7 +19,7 @@ module TypeProf
       klass, new_mid, old_mid = aargs.lead_tys
       new_sym = get_sym("alias", new_mid, ep, scratch) or return
       old_sym = get_sym("alias", old_mid, ep, scratch) or return
-      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym)
+      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym, ep)
       ctn[Type.nil, ep, env]
     end
 
@@ -163,6 +163,66 @@ module TypeProf
       end
     end
 
+    def object_enum_for(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        mid_ty, = aargs.lead_tys
+        naargs = ActualArguments.new(aargs.lead_tys[1..], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
+      elsif aargs.rest_ty
+        mid_ty = aargs.rest_ty
+        naargs = aargs
+      else
+        mid_ty = Type::Symbol.new(:each, Type::Instance.new(Type::Builtin[:sym]))
+        naargs = aargs
+      end
+
+      elem_ty = Type.bot
+      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &blk_ctn|
+        if aargs.lead_tys.size >= 1
+          elem_ty = elem_ty.union(aargs.lead_tys[0])
+        else
+          elem_ty = elem_ty.union(Type.any)
+        end
+        ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+        blk_ctn[Type.any, caller_ep, caller_env]
+      end
+      enum_for_blk_ty = Type::Proc.new(enum_for_blk, Type::Instance.new(Type::Builtin[:proc]))
+
+      naargs = ActualArguments.new(naargs.lead_tys, naargs.rest_ty, naargs.kw_tys, enum_for_blk_ty)
+      mid_ty.each_child do |mid|
+        if mid.is_a?(Type::Symbol)
+          mid = mid.sym
+          scratch.do_send(recv, mid, naargs, ep, env) do |_ret_ty, _ep|
+            ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+          end
+        end
+      end
+    end
+
+    def object_privitive_method(recv, mid, aargs, ep, env, scratch, &ctn)
+      ctn[Type::Symbol.new(ep.ctx.mid, Type::Instance.new(Type::Builtin[:sym])), ep, env]
+    end
+
+    def object_block_given?(recv, mid, aargs, ep, env, scratch, &ctn)
+      procs = Type.bot
+      no_proc = false
+      env.static_env.blk_ty.each_child do |blk_ty|
+        case blk_ty
+        when Type::Proc
+          procs = procs.union(blk_ty)
+        when Type.nil
+          no_proc = true
+        else
+          ctn[Type.bool, ep, env]
+        end
+      end
+      if procs != Type.bot
+        ctn[Type::Instance.new(Type::Builtin[:true]), ep, env.replace_blk_ty(procs)]
+      end
+      if no_proc
+        ctn[Type::Instance.new(Type::Builtin[:false]), ep, env.replace_blk_ty(Type.nil)]
+      end
+    end
+
     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")
@@ -178,7 +238,7 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, false, ep)
+          scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -199,7 +259,29 @@ 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)
+          # 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 +350,25 @@ module TypeProf
       end
 
       mid, = aargs.lead_tys
-      if mid.is_a?(Type::Symbol)
-        mid = mid.sym
-        aargs.blk_ty.each_child do |blk_ty|
-          if blk_ty.is_a?(Type::Proc)
-            blk = blk_ty.block_body
-            case blk
-            when ISeqBlock
-              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, 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 +377,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_accessor", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :accessor)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :accessor, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -302,7 +386,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_reader", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :reader)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :reader, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -311,7 +395,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_writer", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :writer)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :writer, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -444,43 +528,57 @@ 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)
+    def struct_s_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]
+      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 +752,26 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
-      Type::Builtin[:int]       = scratch.get_constant(klass_obj, :Integer)
-      Type::Builtin[:float]     = scratch.get_constant(klass_obj, :Float)
-      Type::Builtin[:rational]  = scratch.get_constant(klass_obj, :Rational)
-      Type::Builtin[: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,19 +786,25 @@ 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))
@@ -718,10 +823,10 @@ module TypeProf
       scratch.set_custom_method(klass_struct, :initialize, Builtin.method(:struct_initialize))
       scratch.set_singleton_custom_method(klass_struct, :new, Builtin.method(:struct_s_new))
 
-      scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require))
-      scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative))
-      scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array))
-      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload))
+      scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require), false)
+      scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative), false)
+      scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array), false)
+      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload), false)
       scratch.set_custom_method(klass_module, :autoload, Builtin.method(:module_autoload))
 
       # remove BasicObject#method_missing