typeprof 0.30.1 → 0.31.1

data/lib/typeprof/core/ast/variable.rb

@@ -17,6 +17,29 @@ module TypeProf::Core
       def retrieve_at(pos)
         yield self if code_range.include?(pos)
       end
+
+      def narrowings
+        @narrowings ||= [
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(false) }),
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(true) }),
+        ]
+      end
+    end
+
+    class ItLocalVariableReadNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+      end
+
+      def attrs = {}
+
+      def install0(genv)
+        @lenv.get_var(:it)
+      end
+
+      def retrieve_at(pos)
+        yield self if code_range.include?(pos)
+      end
     end
 
     class LocalVariableWriteNode < Node
@@ -64,7 +87,7 @@ module TypeProf::Core
         case @lenv.cref.scope_level
         when :class, :instance
           box = @changes.add_ivar_read_box(genv, lenv.cref.cpath, lenv.cref.scope_level == :class, @var)
-          @lenv.apply_read_filter(genv, self, @var, box.ret)
+          @lenv.apply_ivar_narrowing(genv, self, @var, box.ret)
         else
           Source.new()
         end
@@ -73,6 +96,13 @@ module TypeProf::Core
       def retrieve_at(pos)
         yield self if code_range.include?(pos)
       end
+
+      def narrowings
+        @narrowings ||= [
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(false) }),
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(true) }),
+        ]
+      end
     end
 
     class InstanceVariableWriteNode < Node
@@ -289,7 +319,7 @@ module TypeProf::Core
 
       def install0(genv)
         box = @changes.add_cvar_read_box(genv, lenv.cref.cpath, @var)
-        @lenv.apply_read_filter(genv, self, @var, box.ret)
+        @lenv.apply_ivar_narrowing(genv, self, @var, box.ret)
       end
 
       def retrieve_at(pos)

data/lib/typeprof/core/ast.rb

@@ -58,6 +58,7 @@ module TypeProf::Core
       when :begin_node then BeginNode.new(raw_node, lenv)
       when :retry_node then RetryNode.new(raw_node, lenv)
       when :rescue_modifier_node then RescueModifierNode.new(raw_node, lenv)
+      when :rescue_node then RescueNode.new(raw_node, lenv)
 
       # constants
       when :constant_read_node, :constant_path_node
@@ -92,6 +93,8 @@ module TypeProf::Core
       # variables
       when :local_variable_read_node
         LocalVariableReadNode.new(raw_node, lenv)
+      when :it_local_variable_read_node
+        ItLocalVariableReadNode.new(raw_node, lenv)
       when :local_variable_write_node
         LocalVariableWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
       when :local_variable_operator_write_node
@@ -223,7 +226,7 @@ module TypeProf::Core
       when :flip_flop_node then FlipFlopNode.new(raw_node, lenv)
       when :shareable_constant_node then create_node(raw_node.write, lenv)
       when :match_required_node then MatchRequiredNode.new(raw_node, lenv)
-      when :match_predicate_node then MatchPreidcateNode.new(raw_node, lenv)
+      when :match_predicate_node then MatchPredicateNode.new(raw_node, lenv)
 
       # call
       when :super_node then SuperNode.new(raw_node, lenv)
@@ -267,6 +270,8 @@ module TypeProf::Core
         IndexWriteNode.new(raw_node, dummy_node, lenv)
       when :call_target_node
         CallWriteNode.new(raw_node, dummy_node, lenv)
+      when :multi_target_node
+        MultiTargetNode.new(raw_node, dummy_node, lenv)
       else
         pp raw_node
         raise "not supported yet: #{ raw_node.type }"
@@ -343,8 +348,7 @@ module TypeProf::Core
           break
         when :constant_path_node, :constant_path_target_node
           if raw_node.parent
-            # temporarily support old Prism https://bugs.ruby-lang.org/issues/20467
-            names << (raw_node.respond_to?(:name) ? raw_node.name : raw_node.child.name)
+            names << raw_node.name
             raw_node = raw_node.parent
           else
             return names.reverse
@@ -356,7 +360,8 @@ module TypeProf::Core
           return nil
         end
       end
-      return cref.cpath + names.reverse
+      cpath = cref.cpath # annotate
+      return cpath + names.reverse if cpath
     end
 
     def self.parse_rbs(path, src)
@@ -397,6 +402,8 @@ module TypeProf::Core
         SigDefNode.new(raw_decl, lenv)
       when RBS::AST::Members::Include
         SigIncludeNode.new(raw_decl, lenv)
+      when RBS::AST::Members::Prepend
+        SigPrependNode.new(raw_decl, lenv)
       when RBS::AST::Members::Extend
       when RBS::AST::Members::Public
       when RBS::AST::Members::Private
@@ -410,6 +417,12 @@ module TypeProf::Core
         SigAttrAccessorNode.new(raw_decl, lenv)
       when RBS::AST::Declarations::Base
         self.create_rbs_decl(raw_decl, lenv)
+      when RBS::AST::Members::InstanceVariable
+        SigInstanceVariableNode.new(raw_decl, lenv, false)
+      when RBS::AST::Members::ClassInstanceVariable
+        SigInstanceVariableNode.new(raw_decl, lenv, true)
+      when RBS::AST::Members::ClassVariable
+        SigClassVariableNode.new(raw_decl, lenv)
       else
         raise "unsupported: #{ raw_decl.class }"
       end

data/lib/typeprof/core/builtin.rb

@@ -5,12 +5,11 @@ module TypeProf::Core
     end
 
     def class_new(changes, node, ty, a_args, ret)
-      if ty.is_a?(Type::Singleton)
-        ty = ty.get_instance_type(@genv)
-        recv = Source.new(ty)
-        changes.add_method_call_box(@genv, recv, :initialize, a_args, false)
-        changes.add_edge(@genv, Source.new(ty), ret)
-      end
+      type_param_vtxs = ty.mod.type_params.map { Vertex.new(node) }
+      temp_instance_ty = Type::Instance.new(@genv, ty.mod, type_param_vtxs)
+      recv = Source.new(temp_instance_ty)
+      changes.add_method_call_box(@genv, recv, :initialize, a_args, false)
+      changes.add_edge(@genv, recv, ret)
       true
     end
 
@@ -26,7 +25,8 @@ module TypeProf::Core
     def proc_call(changes, node, ty, a_args, ret)
       case ty
       when Type::Proc
-        ty.block.accept_args(@genv, changes, a_args.positionals, ret, false)
+        ty.block.accept_args(@genv, changes, a_args.positionals)
+        ty.block.add_ret(@genv, changes, ret)
         true
       else
         false
@@ -90,10 +90,16 @@ module TypeProf::Core
     def hash_aref(changes, node, ty, a_args, ret)
       if a_args.positionals.size == 1
         case ty
-        when Type::Hash
+        when Type::Hash, Type::Record
           idx = node.positional_args[0]
           idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
-          changes.add_edge(@genv, ty.get_value(idx), ret)
+          value = ty.get_value(idx)
+          if value
+            changes.add_edge(@genv, value, ret)
+          else
+            # Return untyped for unknown fields
+            changes.add_edge(@genv, Source.new(), ret)
+          end
           true
         else
           false

data/lib/typeprof/core/env/method.rb

@@ -41,7 +41,7 @@ module TypeProf::Core
       ActualArguments.new(positionals, splat_flags, keywords, block)
     end
 
-    def get_rest_args(genv, start_rest, end_rest)
+    def get_rest_args(genv, changes, start_rest, end_rest)
       vtxs = []
 
       start_rest.upto(end_rest - 1) do |i|
@@ -50,7 +50,7 @@ module TypeProf::Core
           a_arg.each_type do |ty|
             ty = ty.base_type(genv)
             if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
-              vtxs << ty.args[0].new_vertex(genv, self)
+              vtxs << changes.new_vertex(genv, self, ty.args[0])
             else
               "???"
             end
@@ -82,6 +82,7 @@ module TypeProf::Core
   end
 
   class Block
+    #: (AST::CallBaseNode, Vertex, Array[Vertex], Array[EscapeBox]) -> void
     def initialize(node, f_ary_arg, f_args, next_boxes)
       @node = node
       @f_ary_arg = f_ary_arg
@@ -89,25 +90,26 @@ module TypeProf::Core
       @next_boxes = next_boxes
     end
 
-    attr_reader :node, :f_args, :ret
+    attr_reader :node, :f_args, :next_boxes
 
-    def accept_args(genv, changes, caller_positionals, caller_ret, ret_check)
+    def accept_args(genv, changes, caller_positionals)
       if caller_positionals.size == 1 && @f_args.size >= 2
-        # TODO: support splat "do |a, *b, c|"
-        changes.add_edge(genv, caller_positionals[0].new_vertex(genv, @node), @f_ary_arg)
+        single_arg = caller_positionals[0]
+
+        @f_args.each_with_index do |f_arg, i|
+          elem_vtx = changes.add_splat_box(genv, single_arg, i).ret
+          changes.add_edge(genv, elem_vtx, f_arg)
+        end
       else
         caller_positionals.zip(@f_args) do |a_arg, f_arg|
           changes.add_edge(genv, a_arg, f_arg) if f_arg
         end
       end
-      if ret_check
-        @next_boxes.each do |box|
-          changes.add_edge(genv, caller_ret, box.f_ret)
-        end
-      else
-        @next_boxes.each do |box|
-          changes.add_edge(genv, box.a_ret, caller_ret)
-        end
+    end
+
+    def add_ret(genv, changes, ret)
+      @next_boxes.each do |box|
+        changes.add_edge(genv, box.a_ret, ret)
       end
     end
   end
@@ -126,12 +128,15 @@ module TypeProf::Core
 
     attr_reader :node, :f_args, :ret, :used
 
-    def accept_args(genv, changes, caller_positionals, caller_ret, ret_check)
+    def accept_args(genv, changes, caller_positionals)
       @used = true
       caller_positionals.each_with_index do |a_arg, i|
         changes.add_edge(genv, a_arg.new_vertex(genv, @node), get_f_arg(i))
       end
-      changes.add_edge(genv, caller_ret, @ret)
+    end
+
+    def add_ret(genv, changes, ret)
+      changes.add_edge(genv, ret, @ret)
     end
   end
 end

data/lib/typeprof/core/env/method_entity.rb

@@ -3,6 +3,7 @@ module TypeProf::Core
     def initialize
       @builtin = nil
       @decls = Set[]
+      @overloading_decls = Set[]
       @defs = Set[]
       @aliases = {}
       @method_call_boxes = Set[]
@@ -12,11 +13,19 @@ module TypeProf::Core
     attr_accessor :builtin
 
     def add_decl(decl)
-      @decls << decl
+      if decl.overloading
+        @overloading_decls << decl
+      else
+        @decls << decl
+      end
     end
 
     def remove_decl(decl)
-      @decls.delete(decl) || raise
+      if decl.overloading
+        @overloading_decls.delete(decl) || raise
+      else
+        @decls.delete(decl) || raise
+      end
     end
 
     def add_def(mdef)

data/lib/typeprof/core/env/module_entity.rb

@@ -7,6 +7,8 @@ module TypeProf::Core
       @module_defs = Set[]
       @include_decls = Set[]
       @include_defs = Set[]
+      @prepend_decls = []
+      @prepend_defs = []
 
       @inner_modules = {}
       @outer_module = outer_module
@@ -15,6 +17,7 @@ module TypeProf::Core
       @superclass = nil
       @self_types = {}
       @included_modules = {}
+      @prepended_modules = {}
       @basic_object = @cpath == [:BasicObject]
 
       # child modules (subclasses and all modules that include me)
@@ -46,6 +49,7 @@ module TypeProf::Core
     attr_reader :superclass
     attr_reader :self_types
     attr_reader :included_modules
+    attr_reader :prepended_modules
     attr_reader :child_modules
 
     attr_reader :superclass_type_args
@@ -192,6 +196,26 @@ module TypeProf::Core
       genv.add_static_eval_queue(:parent_modules_changed, self)
     end
 
+    def add_prepend_decl(genv, node)
+      @prepend_decls << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_prepend_decl(genv, node)
+      @prepend_decls.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def add_prepend_def(genv, node)
+      @prepend_defs << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_prepend_def(genv, node)
+      @prepend_defs.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
     def update_parent(genv, origin, old_parent, new_parent_cpath)
       new_parent = new_parent_cpath ? genv.resolve_cpath(new_parent_cpath) : nil
       if old_parent != new_parent
@@ -323,6 +347,30 @@ module TypeProf::Core
           any_updated = true
         end
       end
+      @prepend_decls.each do |pdecl|
+        new_parent_cpath = pdecl.static_ret.last.cpath
+        new_parent, updated = update_parent(genv, pdecl, @prepended_modules[pdecl], new_parent_cpath)
+        if updated
+          if new_parent
+            @prepended_modules[pdecl] = new_parent
+          else
+            @prepended_modules.delete(pdecl) || raise
+          end
+          any_updated = true
+        end
+      end
+      @prepend_defs.each do |pdef|
+        new_parent_cpath = pdef.static_ret ? pdef.static_ret.cpath : nil
+        new_parent, updated = update_parent(genv, pdef, @prepended_modules[pdef], new_parent_cpath)
+        if updated
+          if new_parent
+            @prepended_modules[pdef] = new_parent
+          else
+            @prepended_modules.delete(pdef) || raise
+          end
+          any_updated = true
+        end
+      end
       @included_modules.delete_if do |origin, old_mod|
         if @include_decls.include?(origin) || @include_defs.include?(origin)
           false
@@ -332,6 +380,15 @@ module TypeProf::Core
           true
         end
       end
+      @prepended_modules.delete_if do |origin, old_mod|
+        if @prepend_decls.include?(origin) || @prepend_defs.include?(origin)
+          false
+        else
+          _new_parent, updated = update_parent(genv, origin, old_mod, nil)
+          any_updated ||= updated
+          true
+        end
+      end
 
       if any_updated
         @subclass_checks.each do |mcall_box|

data/lib/typeprof/core/env/narrowing.rb

@@ -0,0 +1,131 @@
+module TypeProf::Core
+  class Narrowing
+    def initialize(map)
+      raise unless map.is_a?(Hash)
+      @map = map
+    end
+
+    attr_reader :map
+
+    def and(other)
+      new_map = @map.dup
+      other.map.each do |var, constraint|
+        new_map[var] = new_map[var] ? new_map[var].and(constraint) : constraint
+      end
+      Narrowing.new(new_map)
+    end
+
+    def or(other)
+      new_map = {}
+      @map.each do |var, constraint|
+        new_map[var] = constraint.or(other.map[var]) if other.map[var]
+      end
+      Narrowing.new(new_map)
+    end
+
+    EmptyNarrowings = [Narrowing.new({}), Narrowing.new({})]
+
+    # Narrowing system for type refinement
+    class Constraint
+      def and(other)
+        AndConstraint.new(self, other)
+      end
+
+      def or(other)
+        OrConstraint.new(self, other)
+      end
+    end
+
+    class IsAConstraint < Constraint
+      def initialize(arg, neg)
+        @arg = arg
+        @neg = neg
+      end
+
+      attr_reader :arg, :neg
+
+      def negate
+        IsAConstraint.new(@arg, !@neg)
+      end
+
+      def inspect
+        @neg ? "!#{@arg}" : "#{@arg}"
+      end
+
+      def narrow(genv, node, vtx)
+        if @arg.static_ret
+          IsAFilter.new(genv, node, vtx, @neg, @arg.static_ret).next_vtx
+        else
+          vtx
+        end
+      end
+    end
+
+    class NilConstraint < Constraint
+      def initialize(neg)
+        @neg = neg
+      end
+
+      attr_reader :neg
+
+      def inspect
+        @neg ? "!nil" : "nil"
+      end
+
+      def negate
+        NilConstraint.new(!@neg)
+      end
+
+      def narrow(genv, node, vtx)
+        NilFilter.new(genv, node, vtx, @neg).next_vtx
+      end
+    end
+
+    class AndConstraint < Constraint
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left, :right
+
+      def inspect
+        "(#{@left.inspect} & #{@right.inspect})"
+      end
+
+      def negate
+        OrConstraint.new(@left.negate, @right.negate)
+      end
+
+      def narrow(genv, node, vtx)
+        @left.narrow(genv, node, @right.narrow(genv, node, vtx))
+      end
+    end
+
+    class OrConstraint < Constraint
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left, :right
+
+      def inspect
+        "(#{@left.inspect} | #{@right.inspect})"
+      end
+
+      def negate
+        AndConstraint.new(@left.negate, @right.negate)
+      end
+
+      def narrow(genv, node, vtx)
+        ret = Vertex.new(node)
+        vtx1 = @left.narrow(genv, node, vtx)
+        vtx2 = @right.narrow(genv, node, vtx)
+        vtx1.add_edge(genv, ret)
+        vtx2.add_edge(genv, ret)
+        ret
+      end
+    end
+  end
+end

data/lib/typeprof/core/env/static_read.rb

@@ -30,10 +30,9 @@ module TypeProf::Core
       @source_modules.clear
     end
 
-    def resolve(genv, cref, break_object)
+    def resolve(genv, cref, search_ancestors, break_object)
       destroy(genv)
 
-      first = true
       while cref
         scope = cref.cpath
         mod = genv.resolve_cpath(scope)
@@ -47,9 +46,9 @@ module TypeProf::Core
 
           return if check_module(genv, mod)
 
-          break unless first
+          break unless search_ancestors
         end
-        first = false
+        search_ancestors = false
         cref = cref.outer
       end
       resolution_failed(genv)
@@ -57,29 +56,31 @@ module TypeProf::Core
   end
 
   class BaseStaticRead < StaticRead
-    def initialize(genv, name, cref)
+    def initialize(genv, name, cref, strict_const_scope)
       super(name)
       @cref = cref
+      @search_ancestors = !strict_const_scope
       genv.add_static_eval_queue(:static_read_changed, self)
     end
 
     attr_reader :cref
 
     def on_scope_updated(genv)
-      resolve(genv, @cref, false)
+      resolve(genv, @cref, @search_ancestors, false)
     end
   end
 
   class ScopedStaticRead < StaticRead
-    def initialize(name, cbase)
+    def initialize(name, cbase, strict_const_scope)
       super(name)
       @cbase = cbase
       @cbase.followers << self if @cbase
+      @search_ancestors = !strict_const_scope
     end
 
     def on_cbase_updated(genv)
       if @cbase && @cbase.cpath
-        resolve(genv, CRef.new(@cbase.cpath, :class, nil, nil), true)
+        resolve(genv, CRef.new(@cbase.cpath, :class, nil, nil), @search_ancestors, true)
       else
         resolution_failed(genv)
       end

data/lib/typeprof/core/env.rb

@@ -8,6 +8,8 @@ module TypeProf::Core
       @run_queue = []
       @run_queue_set = Set[]
 
+      @pending_diagnostic_paths = Set[]
+
       @mod_object = ModuleEntity.new([])
       @mod_object.inner_modules[:Object] = @mod_object
 
@@ -112,7 +114,11 @@ module TypeProf::Core
       ty_env = base_ty_env.dup
       if base_ty.is_a?(Type::Instance)
         base_ty.mod.type_params.zip(base_ty.args) do |param, arg|
-          ty_env[param] = arg
+          ty_env[param] = arg || Source.new
+        end
+      elsif base_ty.is_a?(Type::Singleton)
+        base_ty.mod.type_params&.each do |param|
+          ty_env[param] = Source.new
         end
       end
       args = mod.type_params.zip(type_args).map do |param, arg|
@@ -179,6 +185,19 @@ module TypeProf::Core
       @run_count += run_count
     end
 
+    def process_diagnostic_paths
+      processed_paths = []
+      @pending_diagnostic_paths.each do |path|
+        processed = yield path
+        processed_paths << path if processed
+      end
+      processed_paths.each {|path| @pending_diagnostic_paths.delete(path) }
+    end
+
+    def add_diagnostic_path(path)
+      @pending_diagnostic_paths << path unless @pending_diagnostic_paths.include?(path)
+    end
+
     # just for validation
     def get_vertexes(vtxs)
       @mod_object.get_vertexes(vtxs)
@@ -284,10 +303,11 @@ module TypeProf::Core
       @return_boxes = return_boxes
       @break_vtx = nil
       @next_boxes = []
-      @filters = {}
+      @ivar_narrowings = {}
+      @strict_const_scope = false
     end
 
-    attr_reader :path, :cref, :locals, :return_boxes, :break_vtx, :next_boxes
+    attr_reader :path, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope
 
     def new_var(name, node)
       @locals[name] = Vertex.new(node)
@@ -318,23 +338,32 @@ module TypeProf::Core
     end
 
 
-    def push_read_filter(name, type)
-      (@filters[name] ||= []) << type
+    def push_ivar_narrowing(name, narrowing)
+      raise unless narrowing.is_a?(Narrowing::Constraint)
+      (@ivar_narrowings[name] ||= []) << narrowing
     end
 
-    def pop_read_filter(name)
-      (@filters[name] ||= []).pop
+    def pop_ivar_narrowing(name)
+      (@ivar_narrowings[name] ||= []).pop
     end
 
-    def apply_read_filter(genv, node, name, vtx)
-      if @filters[name] && !@filters[name].empty?
-        case @filters[name].last
-        when :non_nil
-          return NilFilter.new(genv, node, vtx, false).next_vtx
+    def apply_ivar_narrowing(genv, node, name, vtx)
+      if @ivar_narrowings[name] && !@ivar_narrowings[name].empty?
+        # Apply all accumulated narrowings in order
+        @ivar_narrowings[name].each do |narrowing|
+          vtx = narrowing.narrow(genv, node, vtx)
         end
+        return vtx
       end
       vtx
     end
+
+    def use_strict_const_scope
+      @strict_const_scope = true
+      yield
+    ensure
+      @strict_const_scope = false
+    end
   end
 
   class CRef