typeprof 0.31.1 → 0.33.0

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])
@@ -76,7 +80,7 @@ module TypeProf::Core
         # TODO: prepended modules
         yield mod, singleton
         if singleton
-          # TODO: extended modules
+          each_extended_module(mod, &blk)
         else
           each_included_module(mod, &blk)
         end
@@ -91,6 +95,15 @@ module TypeProf::Core
       end
     end
 
+    def each_extended_module(mod, &blk)
+      # An extended module contributes its instance methods (singleton = false)
+      # as the receiver's singleton methods.
+      mod.extended_modules.each do |_ext_decl, ext_mod|
+        yield ext_mod, false
+        each_included_module(ext_mod, &blk)
+      end
+    end
+
     def get_superclass(singleton, mod)
       super_mod = mod.superclass
       if super_mod
@@ -102,6 +115,9 @@ module TypeProf::Core
           else
             return nil
           end
+        elsif mod == @mod_object
+          # Unresolved while loading the core RBS; the Module fallback below would cycle
+          return [singleton, @mod_basic_object]
         elsif mod == @mod_module && !singleton
           return nil
         else
@@ -113,16 +129,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 +233,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 +283,30 @@ module TypeProf::Core
       mod.get_type_alias(name)
     end
 
-    def load_core_rbs(raw_decls)
-      lenv = LocalEnv.new(nil, CRef::Toplevel, {}, [])
+    # Returns the type parameter names of the first generic declaration of cpath
+    def find_type_params(decls, cpath)
+      decls.each do |decl|
+        next unless decl.cpath == cpath
+        next unless decl.respond_to?(:params)
+        params = decl.params
+        return params if params && !params.empty?
+      end
+      nil
+    end
+
+    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)
+      # A module entity has one set of parameter names shared by all its declarations,
+      # so the shim must reuse the core's ones (Array's was `Elem`, and is `E` since RBS 4.1)
+      ary_elem, = find_type_params(decls, [:Array]) || [:Elem]
+      hash_key, hash_val = find_type_params(decls, [:Hash]) || [:K, :V]
+
+      decls += AST.parse_rbs("typeprof-rbs-shim.rbs", <<-RBS, position_encoding)
         class Exception
           include _Exception
         end
@@ -265,12 +314,15 @@ module TypeProf::Core
           include _ToS
           include _ToStr
         end
-        class Array[Elem]
-          include _ToAry[Elem]
-          include _Each[Elem]
+        class Array[#{ ary_elem }]
+          include _ToAry[#{ ary_elem }]
+          include _Each[#{ ary_elem }]
         end
-        class Hash[K, V]
-          include _Each[[K, V]]
+        class Hash[#{ hash_key }, #{ hash_val }]
+          include _Each[[#{ hash_key }, #{ hash_val }]]
+        end
+        class Object
+          include Hash::_Key
         end
       RBS
 
@@ -295,9 +347,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 +389,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 +428,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 +470,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