typeprof 0.30.0 → 0.31.0

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
 

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

@@ -20,28 +20,8 @@ module TypeProf::Core
       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
@@ -83,6 +63,10 @@ module TypeProf::Core
         end
       end
     end
+
+    def new_vertex(genv, origin)
+      raise NotImplementedError
+    end
   end
 
   class Source < BasicVertex
@@ -117,6 +101,7 @@ module TypeProf::Core
     end
 
     def show
+      Fiber[:show_rec] ||= Set[]
       if Fiber[:show_rec].include?(self)
         "...(recursive)..."
       else
@@ -146,6 +131,7 @@ module TypeProf::Core
       when ValueEntity
       when ActualArguments
       when Array
+      when Symbol
       else
         raise "unknown class: #{ origin.class }"
       end

data/lib/typeprof/core/service.rb

@@ -3,7 +3,8 @@ module TypeProf::Core
     def initialize(options)
       @options = options
 
-      @text_nodes = {}
+      @rb_text_nodes = {}
+      @rbs_text_nodes = {}
 
       @genv = GlobalEnv.new
       @genv.load_core_rbs(load_rbs_declarations(@options[:rbs_collection]).declarations)
@@ -26,43 +27,42 @@ module TypeProf::Core
     attr_reader :genv
 
     def reset!
-      @text_nodes.each_value do |node|
-        if node.is_a?(Array)
-          node.each {|n| n.undefine(@genv) }
-        else
-          node.undefine(@genv)
-        end
-      end
+      @rb_text_nodes.each_value {|node| node.undefine(@genv) }
+      @rbs_text_nodes.each_value {|nodes| nodes.each {|n| n.undefine(@genv) } }
       @genv.define_all
-      @text_nodes.each_value do |node|
-        if node.is_a?(Array)
-          node.each {|n| n.uninstall(@genv) }
-        else
-          node.uninstall(@genv)
-        end
-      end
+      @rb_text_nodes.each_value {|node| node.uninstall(@genv) }
+      @rbs_text_nodes.each_value {|nodes| nodes.each {|n| n.uninstall(@genv) } }
       @genv.run_all
-      @text_nodes.clear
+      @rb_text_nodes.clear
+      @rbs_text_nodes.clear
     end
 
     def add_workspace(rb_folder, rbs_folder)
-      Dir.glob(File.expand_path(rb_folder + "/**/*.rb")) do |path|
-        update_rb_file(path, nil)
+      Dir.glob(File.expand_path(rb_folder + "/**/*.{rb,rbs}")) do |path|
+        update_file(path, nil)
       end
-      Dir.glob(File.expand_path(rbs_folder + "/**/*.rbs")) do |path|
-        update_rbs_file(path, nil)
+      Dir.glob(File.expand_path(rbs_folder + "/**/*.{rb,rbs}")) do |path|
+        update_file(path, nil)
+      end
+    end
+
+    def update_file(path, code)
+      if File.extname(path) == ".rbs"
+        update_rbs_file(path, code)
+      else
+        update_rb_file(path, code)
       end
     end
 
     def update_rb_file(path, code)
-      prev_node = @text_nodes[path]
+      prev_node = @rb_text_nodes[path]
 
       code = File.read(path) unless code
       node = AST.parse_rb(path, code)
       return false unless node
 
-      node.diff(@text_nodes[path]) if prev_node
-      @text_nodes[path] = node
+      node.diff(@rb_text_nodes[path]) if prev_node
+      @rb_text_nodes[path] = node
 
       node.define(@genv)
       prev_node.undefine(@genv) if prev_node
@@ -115,7 +115,7 @@ module TypeProf::Core
     end
 
     def update_rbs_file(path, code)
-      prev_decls = @text_nodes[path]
+      prev_decls = @rbs_text_nodes[path]
 
       code = File.read(path) unless code
       begin
@@ -125,7 +125,7 @@ module TypeProf::Core
       end
 
       # TODO: diff
-      @text_nodes[path] = decls
+      @rbs_text_nodes[path] = decls
 
       decls.each {|decl| decl.define(@genv) }
       prev_decls.each {|decl| decl.undefine(@genv) } if prev_decls
@@ -138,14 +138,17 @@ module TypeProf::Core
       true
     end
 
+    def process_diagnostic_paths(&blk)
+      @genv.process_diagnostic_paths(&blk)
+    end
+
     def diagnostics(path, &blk)
-      node = @text_nodes[path]
-      node.diagnostics(@genv, &blk) if node
+      @rb_text_nodes[path]&.each_diagnostic(@genv, &blk)
     end
 
     def definitions(path, pos)
       defs = []
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         node.boxes(:cread) do |box|
           if box.const_read && box.const_read.cdef
             box.const_read.cdef.defs.each do |cdef_node|
@@ -165,6 +168,18 @@ module TypeProf::Core
           boxes.each do |box|
             box.resolve(genv, nil) do |me, _ty, mid, _orig_ty|
               next unless me
+              me.decls.each do |mdecl|
+                next unless mdecl.node.lenv.path
+
+                code_range =
+                  if mdecl.node.respond_to?(:mname_code_range)
+                    mdecl.node.mname_code_range(mid)
+                  else
+                    mdecl.node.code_range
+                  end
+
+                defs << [mdecl.node.lenv.path, code_range]
+              end
               me.defs.each do |mdef|
                 code_range =
                   if mdef.node.respond_to?(:mname_code_range)
@@ -184,7 +199,7 @@ module TypeProf::Core
     end
 
     def type_definitions(path, pos)
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         if node.ret
           ty_defs = []
           node.ret.types.map do |ty, _source|
@@ -206,7 +221,7 @@ module TypeProf::Core
     #: (String, TypeProf::CodePosition) -> Array[[String?, TypeProf::CodeRange]]?
     def references(path, pos)
       refs = []
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         case node
         when AST::DefNode
           if node.mid_code_range.include?(pos)
@@ -246,7 +261,7 @@ module TypeProf::Core
     def rename(path, pos)
       mdefs = []
       cdefs = []
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         node.boxes(:mcall) do |box|
           box.resolve(genv, nil) do |me, _ty, _mid, _orig_ty|
             next unless me
@@ -262,6 +277,13 @@ module TypeProf::Core
             end
           end
         end
+        if node.is_a?(AST::ConstantWriteNode)
+          if node.cname_code_range.include?(pos) && node.static_cpath
+            genv.resolve_const(node.static_cpath).defs.each do |cdef|
+              cdefs << cdef
+            end
+          end
+        end
         if node.is_a?(AST::DefNode) && node.mid_code_range.include?(pos)
           node.boxes(:mdef) do |mdef|
             mdefs << mdef
@@ -298,7 +320,7 @@ module TypeProf::Core
     end
 
     def hover(path, pos)
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         node.boxes(:mcall) do |box|
           boxes = []
           box.changes.boxes.each do |key, box|
@@ -332,7 +354,7 @@ module TypeProf::Core
 
     def code_lens(path)
       cpaths = []
-      @text_nodes[path].traverse do |event, node|
+      @rb_text_nodes[path]&.traverse do |event, node|
         if node.is_a?(AST::ModuleBaseNode)
           if node.static_cpath
             if event == :enter
@@ -356,7 +378,7 @@ module TypeProf::Core
     end
 
     def completion(path, trigger, pos)
-      @text_nodes[path].retrieve_at(pos) do |node|
+      @rb_text_nodes[path]&.retrieve_at(pos) do |node|
         if node.code_range.last == pos.right
           node.ret.types.map do |ty, _source|
             base_ty = ty.base_type(genv)
@@ -386,7 +408,7 @@ module TypeProf::Core
     def dump_declarations(path)
       stack = []
       out = []
-      @text_nodes[path].traverse do |event, node|
+      @rb_text_nodes[path]&.traverse do |event, node|
         case node
         when AST::ModuleNode
           if node.static_cpath
@@ -481,11 +503,7 @@ module TypeProf::Core
           i += 1
         end
 
-        if File.extname(file) == ".rbs"
-          res = update_rbs_file(file, File.read(file))
-        else
-          res = update_rb_file(file, File.read(file))
-        end
+        res = update_file(file, File.read(file))
 
         if res
           true
@@ -493,6 +511,9 @@ module TypeProf::Core
           output.puts "# failed to analyze: #{ file }"
           false
         end
+      rescue => e
+        output.puts "# error: #{ file }"
+        raise e
       end
       if @options[:display_indicator]
         $stderr << "\r\e[K"