typeprof 0.31.1 → 0.32.0

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

@@ -2,60 +2,63 @@ module TypeProf::Core
   class MethodEntity
     def initialize
       @builtin = nil
-      @decls = Set[]
-      @overloading_decls = Set[]
-      @defs = Set[]
-      @aliases = {}
-      @method_call_boxes = Set[]
     end
 
-    attr_reader :decls, :defs, :aliases, :method_call_boxes
     attr_accessor :builtin
 
+    def decls = @decls ||= Set.empty
+    def defs = @defs ||= Set.empty
+    def aliases = @aliases ||= {}
+    def method_call_boxes = @method_call_boxes ||= Set.empty
+
+    private def overloading_decls = @overloading_decls ||= Set.empty
+
     def add_decl(decl)
       if decl.overloading
-        @overloading_decls << decl
+        overloading_decls << decl
       else
-        @decls << decl
+        decls << decl
       end
     end
 
     def remove_decl(decl)
       if decl.overloading
-        @overloading_decls.delete(decl) || raise
+        overloading_decls.delete(decl) || raise
       else
-        @decls.delete(decl) || raise
+        decls.delete(decl) || raise
       end
     end
 
     def add_def(mdef)
-      @defs << mdef
+      defs << mdef
       self
     end
 
     def remove_def(mdef)
-      @defs.delete(mdef) || raise
+      defs.delete(mdef) || raise
     end
 
     def add_alias(node, old_mid)
-      @aliases[node] = old_mid
+      aliases[node] = old_mid
     end
 
     def remove_alias(node)
-      @aliases.delete(node) || raise
+      aliases.delete(node) || raise
     end
 
     def exist?
-      @builtin || !@decls.empty? || !@defs.empty?
+      @builtin || (@decls && !@decls.empty?) || (@defs && !@defs.empty?)
     end
 
     def add_run_all_mdefs(genv)
+      return unless @defs
       @defs.each do |mdef|
         genv.add_run(mdef)
       end
     end
 
     def add_run_all_method_call_boxes(genv)
+      return unless @method_call_boxes
       @method_call_boxes.each do |box|
         genv.add_run(box)
       end

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

@@ -3,13 +3,18 @@ module TypeProf::Core
     def initialize(cpath, outer_module = self)
       @cpath = cpath
 
-      @module_decls = Set[]
-      @module_defs = Set[]
-      @include_decls = Set[]
-      @include_defs = Set[]
+      @module_decls = Set.empty
+      @module_defs = Set.empty
+      @include_decls = Set.empty
+      @include_defs = Set.empty
       @prepend_decls = []
       @prepend_defs = []
 
+      # `class Foo = Bar` / `module Foo = Bar` declarations attached to this entity.
+      # Maps an alias decl to the target ModuleEntity at the time of registration.
+      @alias_decls = {}
+      @alias_target = nil
+
       @inner_modules = {}
       @outer_module = outer_module
 
@@ -25,7 +30,7 @@ module TypeProf::Core
 
       # class Foo[X, Y, Z] < Bar[A, B, C]
       @superclass_type_args = nil # A, B, C
-      @type_params = [] # X, Y, Z
+      @type_params = {} # X, Y, Z
 
       @consts = {}
       @methods = { true => {}, false => {} }
@@ -34,14 +39,16 @@ module TypeProf::Core
       @type_aliases = {}
 
       @static_reads = {}
-      @subclass_checks = Set[]
-      @ivar_reads = Set[] # should be handled in @ivars ??
-      @cvar_reads = Set[]
+      @subclass_checks = Set.empty
+      @ivar_reads = Set.empty # should be handled in @ivars ??
+      @cvar_reads = Set.empty
     end
 
     attr_reader :cpath
     attr_reader :module_decls
     attr_reader :module_defs
+    attr_reader :alias_decls
+    attr_reader :alias_target
 
     attr_reader :inner_modules
     attr_reader :outer_module
@@ -79,7 +86,7 @@ module TypeProf::Core
     end
 
     def exist?
-      !@module_decls.empty? || !@module_defs.empty?
+      !@module_decls.empty? || !@module_defs.empty? || !@alias_decls.empty?
     end
 
     def on_inner_modules_changed(genv, changed_cname)
@@ -115,9 +122,10 @@ module TypeProf::Core
       @module_decls << decl
 
       if @type_params
-        update_type_params if @type_params != decl.params
+        update_type_params
       else
-        @type_params = decl.params
+        @type_params = {}
+        decl.params.zip(decl.params_default_types) {|name, default_type| @type_params[name] = default_type }
       end
 
       if decl.is_a?(AST::SigClassNode) && !@superclass_type_args
@@ -133,7 +141,7 @@ module TypeProf::Core
       @outer_module.get_const(get_cname).remove_decl(decl)
       @module_decls.delete(decl) || raise
 
-      update_type_params if @type_params == decl.params
+      update_type_params
       if decl.is_a?(AST::SigClassNode) && @superclass_type_args == decl.superclass_args
         @superclass_type_args = nil
         @module_decls.each do |decl|
@@ -152,13 +160,12 @@ module TypeProf::Core
       @module_decls.each do |decl|
         params = decl.params
         next unless params
-        if @type_params
-          @type_params = params if (@type_params <=> params) > 0
-        else
-          @type_params = params
+        if !@type_params || @type_params.size < params.size
+          @type_params = {}
+          params.zip(decl.params_default_types) {|name, default_type| @type_params[name] = default_type }
         end
       end
-      @type_params ||= []
+      @type_params ||= {}
       # TODO: report an error if there are multiple inconsistent declarations
     end
 
@@ -176,6 +183,22 @@ module TypeProf::Core
       on_module_removed(genv)
     end
 
+    def add_alias_decl(genv, decl, target_mod)
+      on_module_added(genv)
+      @alias_decls[decl] = target_mod
+      @alias_target = @alias_decls.values.first
+      ce = @outer_module.get_const(get_cname)
+      ce.add_decl(decl)
+      ce
+    end
+
+    def remove_alias_decl(genv, decl)
+      @outer_module.get_const(get_cname).remove_decl(decl)
+      @alias_decls.delete(decl) || raise
+      @alias_target = @alias_decls.values.first
+      on_module_removed(genv)
+    end
+
     def add_include_decl(genv, node)
       @include_decls << node
       genv.add_static_eval_queue(:parent_modules_changed, self)
@@ -237,7 +260,7 @@ module TypeProf::Core
             old_parent.child_modules.delete(self) if set.empty?
           end
           if new_parent
-            set = new_parent.child_modules[self] ||= Set[]
+            set = new_parent.child_modules[self] ||= Set.empty
             set << origin
           end
           return [new_parent, true]
@@ -261,6 +284,8 @@ module TypeProf::Core
             next
           when AST::ModuleNode
             return nil
+          when AST::StructNewNode
+            return []  # inherits from Object (Struct < Object)
           else
             raise
           end
@@ -436,6 +461,19 @@ module TypeProf::Core
       @ivars[singleton][name] ||= ValueEntity.new
     end
 
+    def add_ivar_decl(genv, singleton, name, decl)
+      ive = get_ivar(singleton, name)
+      ive.add_decl(decl)
+      ive.on_decl_changed(genv)
+      ive
+    end
+
+    def remove_ivar_decl(genv, singleton, name, decl)
+      ive = get_ivar(singleton, name)
+      ive.remove_decl(decl)
+      ive.on_decl_changed(genv)
+    end
+
     def get_cvar(name)
       @cvars[name] ||= ValueEntity.new
     end

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

@@ -2,8 +2,8 @@ module TypeProf::Core
   class StaticRead
     def initialize(name)
       @name = name
-      @followers = Set[]
-      @source_modules = Set[]
+      @followers = Set.empty
+      @source_modules = Set.empty
     end
 
     attr_reader :name, :followers
@@ -37,11 +37,11 @@ module TypeProf::Core
         scope = cref.cpath
         mod = genv.resolve_cpath(scope)
         genv.each_superclass(mod, false) do |mod, _singleton|
-          break if mod == genv.mod_object && break_object
+          break if mod == genv.mod_object && (break_object || cref.outer)
 
           unless @source_modules.include?(mod)
             @source_modules << mod
-            (mod.static_reads[@name] ||= Set[]) << self
+            (mod.static_reads[@name] ||= Set.empty) << self
           end
 
           return if check_module(genv, mod)

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,16 +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|
-          ty_env[param] = Source.new
+        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
@@ -213,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
@@ -251,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
@@ -272,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
@@ -295,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
@@ -305,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)
@@ -337,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
@@ -380,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