typeprof 0.31.0 → 0.32.0

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

@@ -1,7 +1,7 @@
 module TypeProf::Core
   class TypeAliasEntity
     def initialize
-      @decls = Set[]
+      @decls = Set.empty
       @type = nil
     end
 

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

@@ -1,9 +1,9 @@
 module TypeProf::Core
   class ValueEntity
     def initialize
-      @decls = Set[]
-      @defs = Set[]
-      @read_boxes = Set[]
+      @decls = Set.empty
+      @defs = Set.empty
+      @read_boxes = Set.empty
       @vtx = Vertex.new(self)
     end
 
@@ -17,6 +17,14 @@ module TypeProf::Core
       @decls.delete(decl) || raise
     end
 
+    # Re-run all read boxes that depend on this entity. Used when a
+    # declaration is added or removed so that dependents (e.g. an
+    # IVarReadBox that previously fell back to the inferred type) can
+    # observe the new state.
+    def on_decl_changed(genv)
+      @read_boxes.each {|box| genv.add_run(box) }
+    end
+
     def add_def(def_)
       @defs << def_
     end
@@ -28,5 +36,19 @@ module TypeProf::Core
     def exist?
       !@decls.empty? || !@defs.empty?
     end
+
+    def on_const_added(genv, cpath)
+      unless exist?
+        parent_mod = genv.resolve_cpath(cpath[0..-2])
+        genv.add_static_eval_queue(:inner_modules_changed, [parent_mod, cpath[-1]])
+      end
+    end
+
+    def on_const_removed(genv, cpath)
+      unless exist?
+        parent_mod = genv.resolve_cpath(cpath[0..-2])
+        genv.add_static_eval_queue(:inner_modules_changed, [parent_mod, cpath[-1]])
+      end
+    end
   end
 end

data/lib/typeprof/core/env.rb

@@ -6,9 +6,9 @@ module TypeProf::Core
       @static_eval_queue = []
 
       @run_queue = []
-      @run_queue_set = Set[]
+      @run_queue_set = Set.empty
 
-      @pending_diagnostic_paths = Set[]
+      @pending_diagnostic_paths = Set.empty
 
       @mod_object = ModuleEntity.new([])
       @mod_object.inner_modules[:Object] = @mod_object
@@ -36,9 +36,12 @@ module TypeProf::Core
       @complex_type = Type::Instance.new(self, resolve_cpath([:Complex]), [])
       @proc_type = Type::Instance.new(self, resolve_cpath([:Proc]), [])
       @symbol_type = Type::Instance.new(self, resolve_cpath([:Symbol]), [])
+      @method_type = Type::Instance.new(self, resolve_cpath([:Method]), [])
       @set_type = Type::Instance.new(self, resolve_cpath([:Set]), [])
       @regexp_type = Type::Instance.new(self, resolve_cpath([:Regexp]), [])
 
+      @bot_type = Type::Bot.new(self)
+
       @run_count = 0
     end
 
@@ -48,7 +51,8 @@ module TypeProf::Core
     attr_reader :cls_type, :mod_type
     attr_reader :obj_type, :nil_type, :true_type, :false_type, :str_type
     attr_reader :int_type, :float_type, :rational_type, :complex_type
-    attr_reader :proc_type, :symbol_type, :set_type, :regexp_type
+    attr_reader :proc_type, :symbol_type, :method_type, :set_type, :regexp_type
+    attr_reader :bot_type
 
     def gen_ary_type(elem_vtx)
       Type::Instance.new(self, @mod_ary, [elem_vtx])
@@ -113,12 +117,20 @@ module TypeProf::Core
     def get_instance_type(mod, type_args, changes, base_ty_env, base_ty)
       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 || Source.new
+        base_ty.mod.type_params.zip(base_ty.args) do |(param, default_ty), arg|
+          ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new)
+        end
+      elsif base_ty.is_a?(Type::Singleton)
+        base_ty.mod.type_params&.each do |(param, default_ty)|
+          ty_env[param] = default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new
         end
       end
-      args = mod.type_params.zip(type_args).map do |param, arg|
-        arg && changes ? arg.covariant_vertex(self, changes, ty_env) : Source.new
+      args = mod.type_params.zip(type_args).map do |(param, default_ty), arg|
+        if changes
+          (arg || default_ty)&.covariant_vertex(self, changes, ty_env) || Source.new
+        else
+          Source.new
+        end
       end
       Type::Instance.new(self, mod, args)
     end
@@ -209,6 +221,18 @@ module TypeProf::Core
       raise unless cpath # annotation
       cpath.each do |cname|
         mod = mod.inner_modules[cname] ||= ModuleEntity.new(mod.cpath + [cname], mod)
+        mod = follow_alias(mod)
+      end
+      mod
+    end
+
+    def follow_alias(mod)
+      visited = nil
+      while mod.alias_target
+        visited ||= Set.empty
+        break if visited.include?(mod) # cycle
+        visited << mod
+        mod = mod.alias_target
       end
       mod
     end
@@ -247,13 +271,14 @@ module TypeProf::Core
       mod.get_type_alias(name)
     end
 
-    def load_core_rbs(raw_decls)
-      lenv = LocalEnv.new(nil, CRef::Toplevel, {}, [])
+    def load_core_rbs(raw_decls, position_encoding)
+      file_context = FileContext.new(nil, position_encoding)
+      lenv = LocalEnv.new(file_context, CRef::Toplevel, {}, [])
       decls = raw_decls.map do |raw_decl|
         AST.create_rbs_decl(raw_decl, lenv)
       end.compact
 
-      decls += AST.parse_rbs("typeprof-rbs-shim.rbs", <<-RBS)
+      decls += AST.parse_rbs("typeprof-rbs-shim.rbs", <<-RBS, position_encoding)
         class Exception
           include _Exception
         end
@@ -268,6 +293,9 @@ module TypeProf::Core
         class Hash[K, V]
           include _Each[[K, V]]
         end
+        class Object
+          include Hash::_Key
+        end
       RBS
 
       # Loading frequently used modules first will reduces constant resolution
@@ -291,9 +319,41 @@ module TypeProf::Core
     end
   end
 
-  class LocalEnv
-    def initialize(path, cref, locals, return_boxes)
+  class FileContext
+    attr_reader :path, :comments, :position_encoding
+    def initialize(path, position_encoding = nil, prism_source = nil, comments = nil)
       @path = path
+      @position_encoding = position_encoding || Encoding::UTF_16LE
+      @prism_source = prism_source
+      @code_units_cache = nil
+      @comments = comments
+    end
+
+    # Returns [start_column, end_column] for a Prism::Location, in the session-configured
+    # position encoding. UTF-8 uses Prism's native byte columns directly (Prism's UTF-8
+    # code_units_cache reports code points, not bytes — see LSP 3.17 spec).
+    def column_offsets_for(prism_location)
+      if @position_encoding == Encoding::UTF_8
+        [prism_location.start_column, prism_location.end_column]
+      else
+        cache = code_units_cache
+        [
+          prism_location.cached_start_code_units_column(cache),
+          prism_location.cached_end_code_units_column(cache),
+        ]
+      end
+    end
+
+    private
+
+    def code_units_cache
+      @code_units_cache ||= @prism_source&.code_units_cache(@position_encoding)
+    end
+  end
+
+  class LocalEnv
+    def initialize(file_context, cref, locals, return_boxes, forward_args = nil)
+      @file_context = file_context
       @cref = cref
       @locals = locals
       @return_boxes = return_boxes
@@ -301,9 +361,16 @@ module TypeProf::Core
       @next_boxes = []
       @ivar_narrowings = {}
       @strict_const_scope = false
+      @forward_args = forward_args
     end
 
-    attr_reader :path, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope
+    attr_reader :file_context, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope
+    attr_accessor :module_function, :forward_args
+
+    def path = @file_context&.path
+    def code_range_from_node(node)
+      TypeProf::CodeRange.from_node(node, @file_context)
+    end
 
     def new_var(name, node)
       @locals[name] = Vertex.new(node)
@@ -333,7 +400,6 @@ module TypeProf::Core
       @break_vtx ||= Vertex.new(:break_vtx)
     end
 
-
     def push_ivar_narrowing(name, narrowing)
       raise unless narrowing.is_a?(Narrowing::Constraint)
       (@ivar_narrowings[name] ||= []) << narrowing
@@ -376,7 +442,7 @@ module TypeProf::Core
       case @scope_level
       when :instance
         mod = genv.resolve_cpath(@cpath || [])
-        type_params = mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+        type_params = mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
         ty = Type::Instance.new(genv, mod, type_params)
         Source.new(ty)
       when :class