typeprof 0.30.1 → 0.31.0

data/lib/typeprof/core/graph/box.rb

@@ -39,18 +39,12 @@ module TypeProf::Core
       @changes.reinstall(genv)
     end
 
-    def diagnostics(genv, &blk)
-      raise self.to_s if !@changes
-      @changes.diagnostics.each(&blk)
-      @changes.boxes.each_value do |box|
-        box.diagnostics(genv, &blk)
-      end
+    def run0(genv, changes)
+      raise NotImplementedError
     end
 
-    #@@new_id = 0
-
     def to_s
-      "#{ self.class.to_s.split("::").last[0] }#{ @id ||= $new_id += 1 }"
+      "#{ self.class.to_s.split("::").last }#{ @id ||= $new_id += 1 }"
     end
 
     alias inspect to_s
@@ -87,7 +81,20 @@ module TypeProf::Core
     attr_reader :node, :rbs_type, :ret
 
     def run0(genv, changes)
-      vtx = @rbs_type.covariant_vertex(genv, changes, {})
+      # Create substitution map for type parameters if we're in a SigInstanceVariableNode within a generic class
+      subst = {}
+      if @node.is_a?(AST::SigInstanceVariableNode) && @node.cpath
+        mod = genv.resolve_cpath(@node.cpath)
+        if mod.type_params && !mod.type_params.empty?
+          # Create a substitution map where each type parameter maps to a type variable vertex
+          subst = mod.type_params.to_h do |param|
+            type_var_vtx = Vertex.new(@node)
+            [param, type_var_vtx]
+          end
+        end
+      end
+
+      vtx = @rbs_type.covariant_vertex(genv, changes, subst)
       changes.add_edge(genv, vtx, @ret)
     end
   end
@@ -142,13 +149,11 @@ module TypeProf::Core
       end
 
       method_type.req_positionals.each_with_index do |ty, i|
-        f_arg = ty.contravariant_vertex(genv, changes, param_map)
-        return false unless a_args.positionals[i].check_match(genv, changes, f_arg)
+        return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
       end
       method_type.post_positionals.each_with_index do |ty, i|
-        f_arg = ty.contravariant_vertex(genv, changes, param_map)
         i -= method_type.post_positionals.size
-        return false unless a_args.positionals[i].check_match(genv, changes, f_arg)
+        return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
       end
 
       start_rest = method_type.req_positionals.size
@@ -157,61 +162,100 @@ module TypeProf::Core
       i = 0
       while i < method_type.opt_positionals.size && start_rest < end_rest
         break if a_args.splat_flags[start_rest]
-        f_arg = method_type.opt_positionals[i].contravariant_vertex(genv, changes, param_map)
-        return false unless a_args.positionals[start_rest].check_match(genv, changes, f_arg)
+        return false unless method_type.opt_positionals[i].typecheck(genv, changes, a_args.positionals[start_rest], param_map)
         i += 1
         start_rest += 1
       end
 
       if start_rest < end_rest
-        vtxs = a_args.get_rest_args(genv, start_rest, end_rest)
+        vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
         while i < method_type.opt_positionals.size
-          f_arg = method_type.opt_positionals[i].contravariant_vertex(genv, changes, param_map)
-          return false if vtxs.any? {|vtx| !vtx.check_match(genv, changes, f_arg) }
+          ty = method_type.opt_positionals[i]
+          return false if vtxs.any? {|vtx| !ty.typecheck(genv, changes, vtx, param_map) }
           i += 1
         end
         if method_type.rest_positionals
-          f_arg = method_type.rest_positionals.contravariant_vertex(genv, changes, param_map)
-          return false if vtxs.any? {|vtx| !vtx.check_match(genv, changes, f_arg) }
+          return false if vtxs.any? {|vtx| !method_type.rest_positionals.typecheck(genv, changes, vtx, param_map) }
         end
       end
 
       return true
     end
 
-    def resolve_overloads(changes, genv, node, param_map, a_args, ret)
-      match_any_overload = false
-      @method_types.each do |method_type|
-        param_map0 = param_map.dup
-        if method_type.type_params
-          method_type.type_params.zip(yield(method_type)) do |var, vtx|
-            param_map0[var] = vtx
-          end
+    def resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, force)
+      param_map0 = param_map.dup
+      if method_type.type_params
+        method_type.type_params.zip(yield(method_type)) do |var, vtx|
+          param_map0[var] = vtx
         end
+      end
 
-        next unless match_arguments?(genv, changes, param_map0, a_args, method_type)
+      unless match_arguments?(genv, changes, param_map0, a_args, method_type)
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "wrong type of arguments") # XXX: more friendly and fine-grained error message
+        end
+        return false
+      end
 
-        rbs_blk = method_type.block
-        next if method_type.block_required && !a_args.block
-        next if !rbs_blk && a_args.block
-        if rbs_blk && a_args.block
-          # rbs_blk_func.optional_keywords, ...
-          a_args.block.each_type do |ty|
-            case ty
-            when Type::Proc
-              blk_f_ret = rbs_blk.return_type.contravariant_vertex(genv, changes, param_map0)
-              blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
-                blk_a_arg.covariant_vertex(genv, changes, param_map0)
+      rbs_blk = method_type.block
+      if method_type.block_required && !a_args.block
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "block is expected") # XXX: more friendly error message
+        end
+        return false
+      end
+      if !rbs_blk && a_args.block
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "block is not expected") # XXX: more friendly error message
+        end
+        return false
+      end
+      if rbs_blk && a_args.block
+        # rbs_blk_func.optional_keywords, ...
+        blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
+          blk_a_arg.covariant_vertex(genv, changes, param_map0)
+        end
+        a_args.block.each_type do |ty|
+          case ty
+          when Type::Proc
+            ty.block.accept_args(genv, changes, blk_a_args)
+
+            if ty.block.is_a?(Block)
+              ty.block.next_boxes.each do |next_box|
+                unless rbs_blk.return_type.typecheck(genv, changes, next_box.a_ret, param_map0)
+                  next_box.wrong_return_type(rbs_blk.return_type.show, changes)
+                end
               end
-
-              ty.block.accept_args(genv, changes, blk_a_args, blk_f_ret, true)
             end
           end
         end
-        ret_vtx = method_type.return_type.covariant_vertex(genv, changes, param_map0)
+      end
+
+      force = true
+      return true
 
+    ensure
+      if force
+        ret_vtx = method_type.return_type.covariant_vertex(genv, changes, param_map0)
         changes.add_edge(genv, ret_vtx, ret)
-        match_any_overload = true
+      end
+    end
+
+    def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
+      if @method_types.size == 1
+        method_type = @method_types.first
+        resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, true, &blk)
+        return
+      end
+
+      match_any_overload = false
+      @method_types.each do |method_type|
+        if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
+          match_any_overload = true
+        end
       end
       unless match_any_overload
         meth = node.mid_code_range ? :mid_code_range : :code_range
@@ -252,53 +296,66 @@ module TypeProf::Core
   end
 
   class EscapeBox < Box
-    def initialize(node, genv, a_ret, f_ret)
+    def initialize(node, genv, a_ret)
       super(node)
       @a_ret = a_ret.new_vertex(genv, node)
-      @f_ret = f_ret
-      @f_ret.add_edge(genv, self)
     end
 
-    attr_reader :a_ret, :f_ret
+    attr_reader :a_ret
 
     def ret = @a_ret
 
     def run0(genv, changes)
-      unless @a_ret.check_match(genv, changes, @f_ret)
-        msg = "expected: #{ @f_ret.show }; actual: #{ @a_ret.show }"
-        case @node
-        when AST::ReturnNode
-          changes.add_diagnostic(:code_range, msg)
-        when AST::DefNode
-          changes.add_diagnostic(:last_stmt_code_range, msg)
-        when AST::NextNode
-          changes.add_diagnostic(:code_range, msg)
-        when AST::CallNode
-          changes.add_diagnostic(:block_last_stmt_code_range, msg)
-        when AST::AttrReaderMetaNode, AST::AttrAccessorMetaNode
-          changes.add_diagnostic(:code_range, msg)
-        else
-          pp @node.class
-        end
+      return
+    end
+
+    def wrong_return_type(f_ret_show, changes)
+      actual_ty = @a_ret.show
+      return if actual_ty == "untyped" # XXX: too ad-hoc?
+      msg = "expected: #{ f_ret_show }; actual: #{ actual_ty }"
+      case @node
+      when AST::ReturnNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      when AST::DefNode
+        changes.add_diagnostic(:last_stmt_code_range, msg, @node)
+      when AST::NextNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      when AST::CallNode
+        changes.add_diagnostic(:block_last_stmt_code_range, msg, @node)
+      when AST::AttrReaderMetaNode, AST::AttrAccessorMetaNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      else
+        pp @node.class
       end
     end
   end
 
   class SplatBox < Box
-    def initialize(node, genv, ary)
+    def initialize(node, genv, ary, idx)
       super(node)
       @ary = ary
+      @idx = idx
       @ary.add_edge(genv, self)
       @ret = Vertex.new(node)
     end
 
-    attr_reader :ary, :ret
+    attr_reader :ary, :idx, :ret
 
     def run0(genv, changes)
       @ary.each_type do |ty|
-        ty = ty.base_type(genv)
-        if ty.mod == genv.mod_ary
-          changes.add_edge(genv, ty.args[0], @ret)
+        case ty
+        when Type::Instance
+          if ty.mod == genv.mod_ary
+            changes.add_edge(genv, ty.args[0], @ret)
+          else
+            "???"
+          end
+        when Type::Array
+          if @idx && @idx < ty.elems.size
+            changes.add_edge(genv, ty.elems[@idx], @ret)
+          else
+            changes.add_edge(genv, ty.get_elem(genv, @idx), @ret)
+          end
         else
           "???"
         end
@@ -323,8 +380,8 @@ module TypeProf::Core
       @hsh.each_type do |ty|
         ty = ty.base_type(genv)
         if ty.mod == genv.mod_hash
-          changes.add_edge(genv, ty.args[0], @unified_key)
-          changes.add_edge(genv, ty.args[1], @unified_val)
+          changes.add_edge(genv, ty.args[0].new_vertex(genv, :__hash_splat), @unified_key)
+          changes.add_edge(genv, ty.args[1].new_vertex(genv, :__hash_splat), @unified_val)
         else
           "???"
         end
@@ -355,11 +412,8 @@ module TypeProf::Core
       end
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.add_def(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
     end
 
     attr_accessor :node
@@ -369,11 +423,8 @@ module TypeProf::Core
     def destroy(genv)
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.remove_def(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
       super(genv)
     end
 
@@ -430,8 +481,11 @@ module TypeProf::Core
       if pass_arguments(changes, genv, a_args)
         # TODO: block
         f_ret = method_type.return_type.contravariant_vertex(genv, changes, param_map0)
+        changes.add_edge(genv, f_ret, @ret)
         @ret_boxes.each do |ret_box|
-          changes.add_edge(genv, f_ret, ret_box.f_ret)
+          unless method_type.return_type.typecheck(genv, changes, ret_box.a_ret, param_map0)
+            ret_box.wrong_return_type(method_type.return_type.show, changes)
+          end
         end
       end
     end
@@ -451,7 +505,7 @@ module TypeProf::Core
 
         start_rest = [a_args.splat_flags.index(true), @f_args.req_positionals.size + @f_args.opt_positionals.size].min
         end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @f_args.post_positionals.size].max
-        rest_vtxs = a_args.get_rest_args(genv, start_rest, end_rest)
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
 
         @f_args.req_positionals.each_with_index do |f_vtx, i|
           if i < start_rest
@@ -590,7 +644,7 @@ module TypeProf::Core
         end
       end
       if @f_args.rest_keywords
-        args << "**#{ Type.strip_parens(@f_args.rest_keywords.show) }"
+        args << "**#{ Type.extract_hash_value_type(Type.strip_parens(@f_args.rest_keywords.show)) }"
       end
 
       if output_parameter_names && @node.is_a?(AST::DefNode)
@@ -610,7 +664,7 @@ module TypeProf::Core
       args = args.join(", ")
       s = args.empty? ? [] : ["(#{ args })"]
       s << "#{ block_show.sort.join(" | ") }" unless block_show.empty?
-      s << "-> #{ @ret.show }"
+      s << "-> #{ @mid == :initialize ? "void" : @ret.show }"
       s.join(" ")
     end
   end
@@ -626,11 +680,8 @@ module TypeProf::Core
 
       me = genv.resolve_method(@cpath, @singleton, @new_mid)
       me.add_alias(self, @old_mid)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
     end
 
     attr_accessor :node
@@ -640,11 +691,8 @@ module TypeProf::Core
     def destroy(genv)
       me = genv.resolve_method(@cpath, @singleton, @new_mid)
       me.remove_alias(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
       super(genv)
     end
 
@@ -661,7 +709,6 @@ module TypeProf::Core
       @recv.add_edge(genv, self)
       @mid = mid
       @a_args = a_args.new_vertexes(genv, node)
-      @a_args.positionals.each {|arg| arg.add_edge(genv, self) }
       @a_args.keywords.add_edge(genv, self) if @a_args.keywords
       @a_args.block.add_edge(genv, self) if @a_args.block
       @ret = Vertex.new(node)
@@ -749,6 +796,16 @@ module TypeProf::Core
         alias_limit = 0
         while ty
           unless skip
+            # First check prepended modules
+            if !ty.is_a?(Type::Singleton)
+              if resolve_prepended_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
+                  yield me, ty, mid, orig_ty
+                end
+                break
+              end
+            end
+
+            # Then check the class/module itself
             me = ty.mod.get_method(ty.is_a?(Type::Singleton), mid)
             changes.add_depended_method_entity(me) if changes
             if !me.aliases.empty?
@@ -767,6 +824,7 @@ module TypeProf::Core
           if ty.is_a?(Type::Singleton)
             # TODO: extended modules
           else
+            # Finally check included modules
             break if resolve_included_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
               yield me, ty, mid, orig_ty
             end
@@ -779,6 +837,38 @@ module TypeProf::Core
       end
     end
 
+    def resolve_prepended_modules(genv, changes, base_ty_env, ty, mid, &blk)
+      found = false
+
+      alias_limit = 0
+      # Process prepended modules in reverse order (last prepended = first in ancestor chain)
+      ty.mod.prepended_modules.reverse_each do |prep_decl, prep_mod|
+        if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
+          prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, base_ty_env, ty)
+        else
+          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          prep_ty = Type::Instance.new(genv, prep_mod, type_params)
+        end
+
+        me = prep_ty.mod.get_method(false, mid)
+        changes.add_depended_method_entity(me) if changes
+        if !me.aliases.empty?
+          mid = me.aliases.values.first
+          alias_limit += 1
+          redo if alias_limit < 5
+        end
+        if me.exist?
+          found = true
+          yield me, prep_ty, mid
+        else
+          found = resolve_prepended_modules(genv, changes, base_ty_env, prep_ty, mid, &blk)
+        end
+        break if found
+      end
+
+      found
+    end
+
     def resolve_included_modules(genv, changes, base_ty_env, ty, mid, &blk)
       found = false
 
@@ -995,4 +1085,24 @@ module TypeProf::Core
       end
     end
   end
+
+  class InstanceTypeBox < Box
+    def initialize(node, genv, singleton_ty_vtx)
+      super(node)
+      @singleton_ty_vtx = singleton_ty_vtx
+      @ret = Vertex.new(node)
+      genv.add_run(self)
+    end
+
+    attr_reader :ret
+
+    def run0(genv, changes)
+      instance_tys = []
+      @singleton_ty_vtx.each_type do |ty|
+        instance_tys << ty.get_instance_type(genv)
+      end
+      source_vtx = Source.new(*instance_tys)
+      changes.add_edge(genv, source_vtx, @ret)
+    end
+  end
 end

data/lib/typeprof/core/graph/change_set.rb

@@ -3,6 +3,7 @@ module TypeProf::Core
     def initialize(node, target)
       @node = node
       @target = target
+      @new_vertexes = {}
       @covariant_types = {}
       @contravariant_types = {}
       @edges = []
@@ -21,30 +22,35 @@ module TypeProf::Core
       @new_depended_superclasses = []
     end
 
-    attr_reader :node, :covariant_types, :edges, :boxes, :diagnostics
+    attr_reader :node, :target, :covariant_types, :contravariant_types, :edges, :boxes, :diagnostics
 
     def reuse(new_node)
       @node = new_node
       @boxes.each_value do |box|
         box.reuse(new_node)
       end
-      @diagnostics.each do |diag|
-        diag.reuse(new_node)
-      end
     end
 
     def copy_from(other)
       @covariant_types = other.covariant_types.dup
+      @contravariant_types = other.contravariant_types.dup
       @edges = other.edges.dup
       @boxes = other.boxes.dup
       @diagnostics = other.diagnostics.dup
 
       other.covariant_types.clear
+      other.contravariant_types.clear
       other.edges.clear
       other.boxes.clear
       other.diagnostics.clear
     end
 
+    def new_vertex(genv, origin, base_vtx)
+      new_vtx = @new_vertexes[base_vtx] ||= Vertex.new(origin)
+      add_edge(genv, base_vtx, new_vtx)
+      new_vtx
+    end
+
     def new_covariant_vertex(genv, sig_type_node)
       # This is used to avoid duplicated vertex generation for the same sig node
       @covariant_types[sig_type_node] ||= Vertex.new(sig_type_node)
@@ -56,8 +62,6 @@ module TypeProf::Core
     end
 
     def add_edge(genv, src, dst)
-      raise src.class.to_s unless src.is_a?(BasicVertex)
-      src.add_edge(genv, dst) if !@edges.include?([src, dst]) && !@new_edges.include?([src, dst])
       @new_edges << [src, dst]
     end
 
@@ -65,84 +69,76 @@ module TypeProf::Core
 
     def add_method_call_box(genv, recv, mid, a_args, subclasses)
       key = [:mcall, recv, mid, a_args, subclasses]
-      return if @new_boxes[key]
-      @new_boxes[key] = MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses)
+      @new_boxes[key] ||= MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses)
     end
 
-    def add_escape_box(genv, a_ret, f_ret)
+    def add_escape_box(genv, a_ret)
       key = [:return, a_ret]
-      return if @new_boxes[key]
-      @new_boxes[key] = EscapeBox.new(@node, genv, a_ret, f_ret)
+      @new_boxes[key] ||= EscapeBox.new(@node, genv, a_ret)
     end
 
-    def add_splat_box(genv, arg)
-      key = [:splat, arg]
-      return if @new_boxes[key]
-      @new_boxes[key] = SplatBox.new(@node, genv, arg)
+    def add_splat_box(genv, arg, idx = nil)
+      key = [:splat, arg, idx]
+      @new_boxes[key] ||= SplatBox.new(@node, genv, arg, idx)
     end
 
     def add_hash_splat_box(genv, arg, unified_key, unified_val)
       key = [:hash_splat, arg, unified_key, unified_val]
-      return if @new_boxes[key]
-      @new_boxes[key] = HashSplatBox.new(@node, genv, arg, unified_key, unified_val)
+      @new_boxes[key] ||= HashSplatBox.new(@node, genv, arg, unified_key, unified_val)
     end
 
     def add_masgn_box(genv, value, lefts, rest_elem, rights)
       key = [:masgn, value, lefts, rest_elem, rights]
-      return if @new_boxes[key]
-      @new_boxes[key] = MAsgnBox.new(@node, genv, value, lefts, rest_elem, rights)
+      @new_boxes[key] ||= MAsgnBox.new(@node, genv, value, lefts, rest_elem, rights)
     end
 
     def add_method_def_box(genv, cpath, singleton, mid, f_args, ret_boxes)
       key = [:mdef, cpath, singleton, mid, f_args, ret_boxes]
-      return if @new_boxes[key]
-      @new_boxes[key] = MethodDefBox.new(@node, genv, cpath, singleton, mid, f_args, ret_boxes)
+      @new_boxes[key] ||= MethodDefBox.new(@node, genv, cpath, singleton, mid, f_args, ret_boxes)
     end
 
     def add_method_decl_box(genv, cpath, singleton, mid, method_types, overloading)
       key = [:mdecl, cpath, singleton, mid, method_types, overloading]
-      return if @new_boxes[key]
-      @new_boxes[key] = MethodDeclBox.new(@node, genv, cpath, singleton, mid, method_types, overloading)
+      @new_boxes[key] ||= MethodDeclBox.new(@node, genv, cpath, singleton, mid, method_types, overloading)
     end
 
     def add_method_alias_box(genv, cpath, singleton, new_mid, old_mid)
       key = [:mdecl, cpath, singleton, new_mid, old_mid]
-      return if @new_boxes[key]
-      @new_boxes[key] = MethodAliasBox.new(@node, genv, cpath, singleton, new_mid, old_mid)
+      @new_boxes[key] ||= MethodAliasBox.new(@node, genv, cpath, singleton, new_mid, old_mid)
     end
 
     def add_const_read_box(genv, static_ret)
       key = [:cread, static_ret]
-      return if @new_boxes[key]
-      @new_boxes[key] = ConstReadBox.new(@node, genv, static_ret)
+      @new_boxes[key] ||= ConstReadBox.new(@node, genv, static_ret)
     end
 
     def add_gvar_read_box(genv, var)
       key = [:gvar_read, var]
-      return if @new_boxes[key]
-      @new_boxes[key] = GVarReadBox.new(@node, genv, var)
+      @new_boxes[key] ||= GVarReadBox.new(@node, genv, var)
     end
 
     def add_ivar_read_box(genv, cpath, singleton, name)
       key = [:ivar_read, cpath, singleton, name]
-      return if @new_boxes[key]
-      @new_boxes[key] = IVarReadBox.new(@node, genv, cpath, singleton, name)
+      @new_boxes[key] ||= IVarReadBox.new(@node, genv, cpath, singleton, name)
     end
 
     def add_cvar_read_box(genv, cpath, name)
       key = [:cvar_read, cpath, name]
-      return if @new_boxes[key]
-      @new_boxes[key] = CVarReadBox.new(@node, genv, cpath, name)
+      @new_boxes[key] ||= CVarReadBox.new(@node, genv, cpath, name)
     end
 
     def add_type_read_box(genv, type)
       key = [:type_read, type]
-      return if @new_boxes[key]
-      @new_boxes[key] = TypeReadBox.new(@node, genv, type)
+      @new_boxes[key] ||= TypeReadBox.new(@node, genv, type)
+    end
+
+    def add_instance_type_box(genv, singleton_ty_vtx)
+      key = [:instance_type, singleton_ty_vtx]
+      @new_boxes[key] ||= InstanceTypeBox.new(@node, genv, singleton_ty_vtx)
     end
 
-    def add_diagnostic(meth, msg)
-      @new_diagnostics << TypeProf::Diagnostic.new(@node, meth, msg)
+    def add_diagnostic(meth, msg, node = @node)
+      @new_diagnostics << TypeProf::Diagnostic.new(node, meth, msg)
     end
 
     def add_depended_value_entity(ve)
@@ -163,6 +159,9 @@ module TypeProf::Core
 
     def reinstall(genv)
       @new_edges.uniq!
+      @new_edges.each do |src, dst|
+        src.add_edge(genv, dst) unless @edges.include?([src, dst])
+      end
       @edges.each do |src, dst|
         src.remove_edge(genv, dst) unless @new_edges.include?([src, dst])
       end
@@ -175,6 +174,14 @@ module TypeProf::Core
       @boxes, @new_boxes = @new_boxes, @boxes
       @new_boxes.clear
 
+      @diagnostics.each do |diag|
+        genv.add_diagnostic_path(diag.node.lenv.path)
+        diag.node.remove_diagnostic(diag)
+      end
+      @new_diagnostics.each do |diag|
+        genv.add_diagnostic_path(diag.node.lenv.path)
+        diag.node.add_diagnostic(diag)
+      end
       @diagnostics, @new_diagnostics = @new_diagnostics, @diagnostics
       @new_diagnostics.clear