typeprof 0.21.11 → 0.30.1

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

@@ -0,0 +1,224 @@
+module TypeProf::Core
+  class ChangeSet
+    def initialize(node, target)
+      @node = node
+      @target = target
+      @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 = []
+    end
+
+    attr_reader :node, :covariant_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
+      @edges = other.edges.dup
+      @boxes = other.boxes.dup
+      @diagnostics = other.diagnostics.dup
+
+      other.covariant_types.clear
+      other.edges.clear
+      other.boxes.clear
+      other.diagnostics.clear
+    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)
+    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)
+    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
+
+    # 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]
+      return if @new_boxes[key]
+      @new_boxes[key] = MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses)
+    end
+
+    def add_escape_box(genv, a_ret, f_ret)
+      key = [:return, a_ret]
+      return if @new_boxes[key]
+      @new_boxes[key] = EscapeBox.new(@node, genv, a_ret, f_ret)
+    end
+
+    def add_splat_box(genv, arg)
+      key = [:splat, arg]
+      return if @new_boxes[key]
+      @new_boxes[key] = SplatBox.new(@node, genv, arg)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    end
+
+    def add_diagnostic(meth, msg)
+      @new_diagnostics << TypeProf::Diagnostic.new(@node, meth, msg)
+    end
+
+    def add_depended_value_entity(ve)
+      @new_depended_value_entities << ve
+    end
+
+    def add_depended_method_entity(me)
+      @new_depended_method_entities << me
+    end
+
+    def add_depended_static_read(static_read)
+      @new_depended_static_reads << static_read
+    end
+
+    def add_depended_superclass(mod)
+      @new_depended_superclasses << mod
+    end
+
+    def reinstall(genv)
+      @new_edges.uniq!
+      @edges.each do |src, dst|
+        src.remove_edge(genv, dst) unless @new_edges.include?([src, dst])
+      end
+      @edges, @new_edges = @new_edges, @edges
+      @new_edges.clear
+
+      @boxes.each do |key, box|
+        box.destroy(genv)
+      end
+      @boxes, @new_boxes = @new_boxes, @boxes
+      @new_boxes.clear
+
+      @diagnostics, @new_diagnostics = @new_diagnostics, @diagnostics
+      @new_diagnostics.clear
+
+      @depended_value_entities.each do |ve|
+        ve.read_boxes.delete(@target) || raise
+      end
+      @new_depended_value_entities.uniq!
+      @new_depended_value_entities.each do |ve|
+        ve.read_boxes << @target
+      end
+      @depended_value_entities, @new_depended_value_entities = @new_depended_value_entities, @depended_value_entities
+      @new_depended_value_entities.clear
+
+      @depended_method_entities.each do |me|
+        me.method_call_boxes.delete(@target) || raise
+      end
+      @new_depended_method_entities.uniq!
+      @new_depended_method_entities.each do |me|
+        me.method_call_boxes << @target
+      end
+      @depended_method_entities, @new_depended_method_entities = @new_depended_method_entities, @depended_method_entities
+      @new_depended_method_entities.clear
+
+      @depended_static_reads.each do |static_read|
+        static_read.followers.delete(@target)
+      end
+      @new_depended_static_reads.uniq!
+      @new_depended_static_reads.each do |static_read|
+        static_read.followers << @target
+      end
+
+      @depended_static_reads, @new_depended_static_reads = @new_depended_static_reads, @depended_static_reads
+      @new_depended_static_reads.clear
+
+      @depended_superclasses.each do |mod|
+        mod.subclass_checks.delete(@target)
+      end
+      @new_depended_superclasses.uniq!
+      @new_depended_superclasses.each do |mod|
+        mod.subclass_checks << @target
+      end
+
+      @depended_superclasses, @new_depended_superclasses = @new_depended_superclasses, @depended_superclasses
+      @new_depended_superclasses.clear
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+module TypeProf::Core
+  class Filter
+    def destroyed
+      false
+    end
+  end
+
+  class NilFilter < Filter
+    def initialize(genv, node, prev_vtx, allow_nil)
+      @node = node
+      @next_vtx = Vertex.new(node)
+      @allow_nil = allow_nil
+      prev_vtx.add_edge(genv, self)
+    end
+
+    attr_reader :next_vtx, :allow_nil
+
+    def filter(types, nil_type)
+      types.select {|ty| (ty == nil_type) == @allow_nil }
+    end
+
+    def on_type_added(genv, src_var, added_types)
+      types = filter(added_types, genv.nil_type)
+      @next_vtx.on_type_added(genv, self, types) unless types.empty?
+    end
+
+    def on_type_removed(genv, src_var, removed_types)
+      types = filter(removed_types, genv.nil_type)
+      @next_vtx.on_type_removed(genv, self, types) unless types.empty?
+    end
+
+    #@@new_id = 0
+
+    def to_s
+      "NF#{ @id ||= $new_id += 1 } -> #{ @next_vtx }"
+    end
+  end
+
+  class IsAFilter < Filter
+    def initialize(genv, node, prev_vtx, neg, const_read)
+      @node = node
+      @types = Set[]
+      @const_read = const_read
+      @const_read.followers << self
+      @next_vtx = Vertex.new(node)
+      prev_vtx.add_edge(genv, self)
+      @neg = neg
+    end
+
+    attr_reader :next_vtx
+
+    def on_type_added(genv, src_var, added_types)
+      added_types.each do |ty|
+        @types << ty
+      end
+      run(genv)
+    end
+
+    def on_type_removed(genv, src_var, removed_types)
+      removed_types.each do |ty|
+        @types.delete(ty) || raise
+      end
+      run(genv)
+    end
+
+    def run(genv)
+      if @const_read && @const_read.cpath
+        passed_types = []
+        @types.each do |ty|
+          base_ty = ty.base_type(genv)
+          subclass = false
+          genv.each_superclass(base_ty.mod, base_ty.is_a?(Type::Singleton)) do |mod, singleton|
+            if mod.cpath == @const_read.cpath
+              subclass = true
+              break
+            end
+          end
+          passed_types << ty if subclass != @neg
+        end
+      else
+        passed_types = @types.to_a
+      end
+      added_types = passed_types - @next_vtx.types.keys
+      removed_types = @next_vtx.types.keys - passed_types
+      @next_vtx.on_type_added(genv, self, added_types)
+      @next_vtx.on_type_removed(genv, self, removed_types)
+    end
+
+    #@@new_id = 0
+
+    def to_s
+      "NF#{ @id ||= $new_id += 1 } -> #{ @next_vtx }"
+    end
+  end
+
+  class BotFilter < Filter
+    def initialize(genv, node, prev_vtx, base_vtx)
+      @node = node
+      @types = {}
+      @prev_vtx = prev_vtx
+      @next_vtx = Vertex.new(node)
+      @base_vtx = base_vtx
+      base_vtx.add_edge(genv, self)
+      prev_vtx.add_edge(genv, self) if prev_vtx != base_vtx
+    end
+
+    attr_reader :types, :prev_vtx, :next_vtx, :base_vtx
+
+    def filter(types)
+      types.select {|ty| (ty == genv.nil_type) == @allow_nil }
+    end
+
+    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))
+          @next_vtx.on_type_removed(genv, self, @types.keys & @next_vtx.types.keys) # XXX: smoke/control/bot2.rb
+        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))
+          # ignore
+        else
+          @next_vtx.on_type_added(genv, self, added_types - @next_vtx.types.keys) # XXX: smoke/control/bot4.rb
+        end
+      end
+    end
+
+    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))
+          # ignore
+        else
+          @next_vtx.on_type_added(genv, self, @types.keys - @next_vtx.types.keys) # XXX: smoke/control/bot4.rb
+        end
+      else
+        removed_types.each do |ty|
+          @types.delete(ty) || raise
+        end
+        if @base_vtx.types.size == 1 && @base_vtx.types.include?(Type::Bot.new(genv))
+          # ignore
+        else
+          @next_vtx.on_type_removed(genv, self, removed_types & @next_vtx.types.keys) # XXX: smoke/control/bot2.rb
+        end
+      end
+    end
+
+    #@@new_id = 0
+
+    def to_s
+      "BF#{ @id ||= $new_id += 1 } -> #{ @next_vtx }"
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+module TypeProf::Core
+  class BasicVertex
+    def initialize(types)
+      @types = types
+      @types_to_be_added = {}
+    end
+
+    attr_reader :types
+
+    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
+        end
+        @types_to_be_added.clear
+        h.each_key(&blk)
+      end
+    end
+
+    def check_match(genv, changes, vtx)
+      vtx.each_type do |ty|
+        if ty.is_a?(Type::Var)
+          changes.add_edge(genv, self, ty.vtx) if self != ty.vtx
+          return true
+        end
+      end
+
+      return true if @types.empty?
+      return true if vtx.types.empty?
+
+      each_type do |ty|
+        return true if vtx.types.include?(ty) # fast path
+        if ty.check_match(genv, changes, vtx)
+          return true
+        end
+      end
+
+      return false
+    end
+
+    def show
+      Fiber[:show_rec] ||= Set[]
+      if Fiber[:show_rec].include?(self)
+        "untyped"
+      else
+        begin
+          Fiber[:show_rec] << self
+          types = []
+          bot = @types.keys.any? {|ty| ty.is_a?(Type::Bot) }
+          optional = true_exist = false_exist = false
+          each_type do |ty|
+            if ty.is_a?(Type::Instance)
+              case ty.mod.cpath
+              when [:NilClass] then optional = true
+              when [:TrueClass] then true_exist = true
+              when [:FalseClass] then false_exist = true
+              end
+            end
+          end
+          bool = true_exist && false_exist
+          types << "bool" if bool
+          each_type do |ty, _source|
+            if ty.is_a?(Type::Instance)
+              next if ty.mod.cpath == [:NilClass]
+              next if bool && (ty.mod.cpath == [:TrueClass] || ty.mod.cpath == [:FalseClass])
+            end
+            next if ty.is_a?(Type::Bot)
+            types << ty.show
+          end
+          types = types.uniq.sort
+          case types.size
+          when 0
+            optional ? "nil" : bot ? "bot" : "untyped"
+          when 1
+            types.first + (optional ? "?" : "")
+          else
+            "(#{ types.join(" | ") })" + (optional ? "?" : "")
+          end
+        ensure
+          Fiber[:show_rec].delete(self) || raise
+        end
+      end
+    end
+  end
+
+  class Source < BasicVertex
+    def initialize(*tys)
+      types = {}
+      tys.each do |ty|
+        raise ty.inspect unless ty.is_a?(Type)
+        types[ty] = true
+      end
+      super(types)
+    end
+
+    def on_type_added(genv, src_var, added_types)
+      # TODO: need to report error?
+    end
+
+    def on_type_removed(genv, src_var, removed_types)
+    end
+
+    def new_vertex(genv, origin)
+      nvtx = Vertex.new(origin)
+      add_edge(genv, nvtx)
+      nvtx
+    end
+
+    def add_edge(genv, nvtx)
+      nvtx.on_type_added(genv, self, @types.keys)
+    end
+
+    def remove_edge(genv, nvtx)
+      nvtx.on_type_removed(genv, self, @types.keys)
+    end
+
+    def show
+      Fiber[:show_rec] ||= Set[]
+      if Fiber[:show_rec].include?(self)
+        "...(recursive)..."
+      else
+        begin
+          Fiber[:show_rec] << self
+          @types.empty? ? "untyped" : @types.keys.map {|ty| ty.show }.sort.join(" | ")
+        ensure
+          Fiber[:show_rec].delete(self) || raise
+        end
+      end
+    end
+
+    def to_s
+      "<src:#{ show }>"
+    end
+
+    alias inspect to_s
+  end
+
+  class Vertex < BasicVertex
+    def initialize(origin)
+      # Note that origin is just for debug.
+      # When an AST node is reused, the value of the origin will be invalid.
+      case origin
+      when AST::Node
+      when RBS::AST::Declarations::Base
+      when ValueEntity
+      when ActualArguments
+      when Array
+      when Symbol
+      else
+        raise "unknown class: #{ origin.class }"
+      end
+      @next_vtxs = Set[]
+      super({})
+    end
+
+    attr_reader :next_vtxs, :types
+
+    def on_type_added(genv, src_var, added_types)
+      new_added_types = []
+      added_types.each do |ty|
+        if @types[ty]
+          @types[ty] << src_var
+        else
+          set = Set[]
+          begin
+            @types[ty] = set
+          rescue
+            @types_to_be_added[ty] = set
+          end
+          set << src_var
+          new_added_types << ty
+        end
+      end
+      unless new_added_types.empty?
+        @next_vtxs.each do |nvtx|
+          nvtx.on_type_added(genv, self, new_added_types)
+        end
+      end
+    end
+
+    def on_type_removed(genv, src_var, removed_types)
+      new_removed_types = []
+      removed_types.each do |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
+        end
+      end
+      unless new_removed_types.empty?
+        @next_vtxs.each do |nvtx|
+          nvtx.on_type_removed(genv, self, new_removed_types)
+        end
+      end
+    end
+
+    def new_vertex(genv, origin)
+      nvtx = Vertex.new(origin)
+      add_edge(genv, nvtx)
+      nvtx
+    end
+
+    def add_edge(genv, nvtx)
+      @next_vtxs << nvtx
+      nvtx.on_type_added(genv, self, @types.keys) unless @types.empty?
+    end
+
+    def remove_edge(genv, nvtx)
+      @next_vtxs.delete(nvtx) || raise
+      nvtx.on_type_removed(genv, self, @types.keys) unless @types.empty?
+    end
+
+    $new_id = 0 # TODO: Use class variable
+
+    def to_s
+      "v#{ @id ||= $new_id += 1 }"
+    end
+
+    alias inspect to_s
+  end
+end