typeprof 0.31.1 → 0.33.0

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

@@ -3,30 +3,33 @@ module TypeProf::Core
     def initialize(node, target)
       @node = node
       @target = target
-      @new_vertexes = {}
-      @covariant_types = {}
-      @contravariant_types = {}
-      @edges = []
-      @new_edges = []
-      @boxes = {}
-      @new_boxes = {}
       @diagnostics = []
       @new_diagnostics = []
-      @depended_value_entities = []
-      @new_depended_value_entities = []
-      @depended_method_entities = []
-      @new_depended_method_entities = []
-      @depended_static_reads = []
-      @new_depended_static_reads = []
-      @depended_superclasses = []
-      @new_depended_superclasses = []
+      if target
+        @depended_value_entities = []
+        @new_depended_value_entities = []
+        @depended_method_entities = []
+        @new_depended_method_entities = []
+        @depended_static_reads = []
+        @new_depended_static_reads = []
+        @depended_superclasses = []
+        @new_depended_superclasses = []
+      end
     end
 
-    attr_reader :node, :target, :covariant_types, :contravariant_types, :edges, :boxes, :diagnostics
+    attr_reader :node, :target, :diagnostics
+
+    def covariant_types = @covariant_types ||= {}
+    def contravariant_types = @contravariant_types ||= {}
+    def edges = @edges ||= {}
+    def boxes = @boxes ||= {}
+
+    private def new_edges = @new_edges ||= {}
+    private def new_boxes = @new_boxes ||= {}
 
     def reuse(new_node)
       @node = new_node
-      @boxes.each_value do |box|
+      boxes.each_value do |box|
         box.reuse(new_node)
       end
     end
@@ -46,6 +49,7 @@ module TypeProf::Core
     end
 
     def new_vertex(genv, origin, base_vtx)
+      @new_vertexes ||= {}
       new_vtx = @new_vertexes[base_vtx] ||= Vertex.new(origin)
       add_edge(genv, base_vtx, new_vtx)
       new_vtx
@@ -53,88 +57,93 @@ module TypeProf::Core
 
     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)
+      covariant_types[sig_type_node] ||= Vertex.new(sig_type_node)
     end
 
     def new_contravariant_vertex(genv, sig_type_node)
       # This is used to avoid duplicated vertex generation for the same sig node
-      @contravariant_types[sig_type_node] ||= Vertex.new(sig_type_node)
+      contravariant_types[sig_type_node] ||= Vertex.new(sig_type_node)
     end
 
     def add_edge(genv, src, dst)
-      @new_edges << [src, dst]
+      (new_edges[src] ||= {})[dst] = true
     end
 
     # TODO: if an edge is removed during one analysis, we may need to remove sub-boxes?
 
-    def add_method_call_box(genv, recv, mid, a_args, subclasses)
-      key = [:mcall, recv, mid, a_args, subclasses]
-      @new_boxes[key] ||= MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses)
+    def add_method_call_box(genv, recv, mid, a_args, subclasses, suppress_errors: false, unresolved_recv: nil)
+      key = [:mcall, recv, mid, a_args, subclasses, suppress_errors, unresolved_recv]
+      new_boxes[key] ||= MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses, suppress_errors: suppress_errors, unresolved_recv: unresolved_recv)
     end
 
     def add_escape_box(genv, a_ret)
       key = [:return, a_ret]
-      @new_boxes[key] ||= EscapeBox.new(@node, genv, a_ret)
+      new_boxes[key] ||= EscapeBox.new(@node, genv, a_ret)
     end
 
-    def add_splat_box(genv, arg, idx = nil)
-      key = [:splat, arg, idx]
-      @new_boxes[key] ||= SplatBox.new(@node, genv, arg, idx)
+    def add_splat_box(genv, arg, idx = nil, unresolved_recv = nil)
+      key = [:splat, arg, idx, unresolved_recv]
+      new_boxes[key] ||= SplatBox.new(@node, genv, arg, idx, unresolved_recv)
+    end
+
+    def add_keyword_merge_box(genv, rest, literal_pairs, fallback)
+      key = [:kw_merge, rest, literal_pairs, fallback]
+      new_boxes[key] ||= KeywordMergeBox.new(@node, genv, rest, literal_pairs, fallback)
     end
 
     def add_hash_splat_box(genv, arg, unified_key, unified_val)
       key = [:hash_splat, arg, unified_key, unified_val]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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]
-      @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)
+      new_boxes[key] ||= InstanceTypeBox.new(@node, genv, singleton_ty_vtx)
     end
 
     def add_diagnostic(meth, msg, node = @node)
@@ -158,21 +167,28 @@ module TypeProf::Core
     end
 
     def reinstall(genv)
-      @new_edges.uniq!
-      @new_edges.each do |src, dst|
-        src.add_edge(genv, dst) unless @edges.include?([src, dst])
+      # Edges stored as nested hashes: {src => {dst => true}}
+      new_edges.each do |src, new_dsts|
+        old_dsts = edges[src]
+        new_dsts.each_key do |dst|
+          src.add_edge(genv, dst) unless old_dsts&.key?(dst)
+        end
       end
-      @edges.each do |src, dst|
-        src.remove_edge(genv, dst) unless @new_edges.include?([src, dst])
+      edges.each do |src, old_dsts|
+        new_dsts = new_edges[src]
+        old_dsts.each_key do |dst|
+          src.remove_edge(genv, dst) unless new_dsts&.key?(dst)
+        end
       end
       @edges, @new_edges = @new_edges, @edges
-      @new_edges.clear
+      new_edges.each_value(&:clear)
+      new_edges.clear
 
-      @boxes.each do |key, box|
+      boxes.each do |key, box|
         box.destroy(genv)
       end
       @boxes, @new_boxes = @new_boxes, @boxes
-      @new_boxes.clear
+      new_boxes.clear
 
       @diagnostics.each do |diag|
         genv.add_diagnostic_path(diag.node.lenv.path)
@@ -185,6 +201,8 @@ module TypeProf::Core
       @diagnostics, @new_diagnostics = @new_diagnostics, @diagnostics
       @new_diagnostics.clear
 
+      return unless @target
+
       @depended_value_entities.each do |ve|
         ve.read_boxes.delete(@target) || raise
       end

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

@@ -39,7 +39,7 @@ module TypeProf::Core
   class IsAFilter < Filter
     def initialize(genv, node, prev_vtx, neg, const_read)
       @node = node
-      @types = Set[]
+      @types = Set.empty
       @const_read = const_read
       @const_read.followers << self
       @next_vtx = Vertex.new(node)
@@ -112,14 +112,17 @@ module TypeProf::Core
 
     def on_type_added(genv, src_var, added_types)
       if src_var == @base_vtx
-        if @base_vtx.types.size == 1 && @base_vtx.types.include?(Type::Bot.new(genv))
+        if @base_vtx.types.size == 1 && @base_vtx.types.include?(genv.bot_type)
           @next_vtx.on_type_removed(genv, self, @types.keys & @next_vtx.types.keys) # XXX: smoke/control/bot2.rb
+        else
+          # base_vtx is no longer bot-only; restore any previously suppressed types
+          @next_vtx.on_type_added(genv, self, @types.keys - @next_vtx.types.keys)
         end
       else
         added_types.each do |ty|
           @types[ty] = true
         end
-        if @base_vtx.types.size == 1 && @base_vtx.types.include?(Type::Bot.new(genv))
+        if @base_vtx.types.size == 1 && @base_vtx.types.include?(genv.bot_type)
           # ignore
         else
           @next_vtx.on_type_added(genv, self, added_types - @next_vtx.types.keys) # XXX: smoke/control/bot4.rb
@@ -129,7 +132,7 @@ module TypeProf::Core
 
     def on_type_removed(genv, src_var, removed_types)
       if src_var == @base_vtx
-        if @base_vtx.types.size == 1 && @base_vtx.types.include?(Type::Bot.new(genv))
+        if @base_vtx.types.size == 1 && @base_vtx.types.include?(genv.bot_type)
           # ignore
         else
           @next_vtx.on_type_added(genv, self, @types.keys - @next_vtx.types.keys) # XXX: smoke/control/bot4.rb
@@ -138,7 +141,7 @@ module TypeProf::Core
         removed_types.each do |ty|
           @types.delete(ty) || raise
         end
-        if @base_vtx.types.size == 1 && @base_vtx.types.include?(Type::Bot.new(genv))
+        if @base_vtx.types.size == 1 && @base_vtx.types.include?(genv.bot_type)
           # ignore
         else
           @next_vtx.on_type_removed(genv, self, removed_types & @next_vtx.types.keys) # XXX: smoke/control/bot2.rb

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

@@ -2,7 +2,6 @@ module TypeProf::Core
   class BasicVertex
     def initialize(types)
       @types = types
-      @types_to_be_added = {}
     end
 
     attr_reader :types
@@ -10,18 +9,20 @@ module TypeProf::Core
     def each_type(&blk)
       @types.each_key(&blk)
 
-      until @types_to_be_added.empty?
-        h = @types_to_be_added.dup
-        h.each do |ty, source|
-          @types[ty] = source
+      if @types_to_be_added
+        until @types_to_be_added.empty?
+          h = @types_to_be_added.dup
+          h.each do |ty, source|
+            @types[ty] = source
+          end
+          @types_to_be_added.clear
+          h.each_key(&blk)
         end
-        @types_to_be_added.clear
-        h.each_key(&blk)
       end
     end
 
     def show
-      Fiber[:show_rec] ||= Set[]
+      Fiber[:show_rec] ||= Set.empty
       if Fiber[:show_rec].include?(self)
         "untyped"
       else
@@ -101,7 +102,7 @@ module TypeProf::Core
     end
 
     def show
-      Fiber[:show_rec] ||= Set[]
+      Fiber[:show_rec] ||= Set.empty
       if Fiber[:show_rec].include?(self)
         "...(recursive)..."
       else
@@ -135,29 +136,29 @@ module TypeProf::Core
       else
         raise "unknown class: #{ origin.class }"
       end
-      @next_vtxs = Set[]
+      @next_vtxs = Set.empty
       super({})
     end
 
     attr_reader :next_vtxs, :types
 
     def on_type_added(genv, src_var, added_types)
-      new_added_types = []
+      new_added_types = nil
       added_types.each do |ty|
         if @types[ty]
           @types[ty] << src_var
         else
-          set = Set[]
+          set = Set.empty
           begin
             @types[ty] = set
           rescue
-            @types_to_be_added[ty] = set
+            (@types_to_be_added ||= {})[ty] = set
           end
           set << src_var
-          new_added_types << ty
+          (new_added_types ||= []) << ty
         end
       end
-      unless new_added_types.empty?
+      if new_added_types
         @next_vtxs.each do |nvtx|
           nvtx.on_type_added(genv, self, new_added_types)
         end
@@ -165,16 +166,16 @@ module TypeProf::Core
     end
 
     def on_type_removed(genv, src_var, removed_types)
-      new_removed_types = []
+      new_removed_types = nil
       removed_types.each do |ty|
-        raise "!!! not implemented" if @types_to_be_added[ty]
+        raise "!!! not implemented" if @types_to_be_added&.[](ty)
         @types[ty].delete(src_var) || raise
         if @types[ty].empty?
           @types.delete(ty) || raise
-          new_removed_types << ty
+          (new_removed_types ||= []) << ty
         end
       end
-      unless new_removed_types.empty?
+      if new_removed_types
         @next_vtxs.each do |nvtx|
           nvtx.on_type_removed(genv, self, new_removed_types)
         end