typeprof 0.32.0 → 0.33.1

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

@@ -48,10 +48,33 @@ module TypeProf::Core
         @positionals + [@keywords],
         @splat_flags + [false],
         nil,
-        @block
+        @block,
       )
     end
 
+    def prepend_positionals(positionals, splat_flags)
+      return self if positionals.empty?
+
+      ActualArguments.new(positionals + @positionals, splat_flags + @splat_flags, @keywords, @block)
+    end
+
+    def with_keywords(keywords)
+      ActualArguments.new(@positionals, @splat_flags, keywords, @block)
+    end
+
+    def with_block(block, omittable: false)
+      ActualArguments.new(@positionals, @splat_flags, @keywords, block)
+    end
+
+    def add_box_edges(genv, box)
+      @keywords.add_edge(genv, box) if @keywords
+      @block.add_edge(genv, box) if @block
+    end
+
+    def normalize_for_method_call(_genv)
+      self
+    end
+
     def get_rest_args(genv, changes, start_rest, end_rest)
       vtxs = []
 
@@ -95,45 +118,175 @@ module TypeProf::Core
     end
   end
 
+  class ForwardingActualArguments < ActualArguments
+    def initialize(positionals, splat_flags, keywords, block, positionals_omittable, keywords_omittable, block_omittable, activation, activation_required)
+      super(positionals, splat_flags, keywords, block)
+      @positionals_omittable = positionals_omittable
+      @keywords_omittable = keywords_omittable
+      @block_omittable = block_omittable
+      @activation = activation
+      @activation_required = activation_required
+    end
+
+    attr_reader :positionals_omittable, :keywords_omittable, :block_omittable
+
+    def new_vertexes(genv, node)
+      positionals = @positionals.map {|arg| arg.new_vertex(genv, node) }
+      splat_flags = @splat_flags
+      keywords = @keywords ? @keywords.new_vertex(genv, node) : nil
+      block = @block ? @block.new_vertex(genv, node) : nil
+      activation = @activation.new_vertex(genv, node)
+      ForwardingActualArguments.new(positionals, splat_flags, keywords, block, @positionals_omittable, @keywords_omittable, @block_omittable, activation, @activation_required)
+    end
+
+    def with_keywords_as_last_positional_hash
+      return self unless @keywords
+
+      ForwardingActualArguments.new(
+        @positionals + [@keywords],
+        @splat_flags + [false],
+        nil,
+        @block,
+        @positionals_omittable + [false],
+        false,
+        @block_omittable,
+        @activation,
+        @activation_required,
+      )
+    end
+
+    def prepend_positionals(positionals, splat_flags)
+      return self if positionals.empty?
+
+      ForwardingActualArguments.new(
+        positionals + @positionals,
+        splat_flags + @splat_flags,
+        @keywords,
+        @block,
+        ::Array.new(positionals.size, false) + @positionals_omittable,
+        @keywords_omittable,
+        @block_omittable,
+        @activation,
+        @activation_required,
+      )
+    end
+
+    def with_keywords(keywords, keywords_omittable: false)
+      ForwardingActualArguments.new(
+        @positionals,
+        @splat_flags,
+        keywords,
+        @block,
+        @positionals_omittable,
+        keywords_omittable,
+        @block_omittable,
+        @activation,
+        @activation_required,
+      )
+    end
+
+    def with_block(block, omittable: false)
+      ForwardingActualArguments.new(
+        @positionals,
+        @splat_flags,
+        @keywords,
+        block,
+        @positionals_omittable,
+        @keywords_omittable,
+        omittable,
+        @activation,
+        @activation_required,
+      )
+    end
+
+    def add_box_edges(genv, box)
+      @activation.add_edge(genv, box)
+      super
+    end
+
+    def normalize_for_method_call(genv)
+      if @activation.types.empty?
+        return nil if @activation_required
+        return self
+      end
+
+      positionals = []
+      splat_flags = []
+
+      @positionals.each_with_index do |arg, i|
+        unless @positionals_omittable[i] && @splat_flags[i] && empty_omittable_splat_argument?(genv, arg)
+          positionals << arg
+          splat_flags << @splat_flags[i]
+        end
+      end
+
+      keywords = @keywords
+      keywords = nil if @keywords_omittable && keywords && keywords.types.empty?
+
+      block = @block
+      block = nil if @block_omittable && block && block.types.empty?
+
+      ActualArguments.new(positionals, splat_flags, keywords, block)
+    end
+
+    private
+
+    def empty_omittable_splat_argument?(genv, arg)
+      empty = true
+      arg.each_type do |ty|
+        ty = ty.base_type(genv)
+        unless ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0] && ty.args[0].types.empty?
+          empty = false
+          break
+        end
+      end
+      empty
+    end
+  end
+
   class ForwardingArguments
-    def initialize(req_positionals, opt_positionals, opt_positional_elems, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block)
+    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation)
       @req_positionals = req_positionals
       @opt_positionals = opt_positionals
-      @opt_positional_elems = opt_positional_elems
       @rest_positionals = rest_positionals
       @post_positionals = post_positionals
       @req_keyword_pairs = req_keyword_pairs
       @opt_keyword_pairs = opt_keyword_pairs
       @rest_keywords = rest_keywords
       @block = block
+      @activation = activation
     end
 
-    attr_reader :block
-
-    def to_actual_arguments(genv, changes, node)
-      positionals = @req_positionals.dup
+    def to_actual_arguments(genv, changes, node, include_leading_positionals: true, activation_required: false)
+      positionals = include_leading_positionals ? @req_positionals.dup : []
       splat_flags = ::Array.new(positionals.size, false)
+      positionals_omittable = ::Array.new(positionals.size, false)
 
-      @opt_positionals.each do |arg|
-        positionals << arg
+      @opt_positionals.each do |elem_vtx|
+        positionals << Source.new(genv.gen_ary_type(elem_vtx))
         splat_flags << true
+        positionals_omittable << true
       end
 
       if @rest_positionals
-        positionals << @rest_positionals
+        positionals << Source.new(genv.gen_ary_type(@rest_positionals))
         splat_flags << true
+        positionals_omittable << true
       end
 
       @post_positionals.each do |arg|
         positionals << arg
         splat_flags << false
+        positionals_omittable << false
       end
 
-      keywords = build_keyword_args(genv, changes, node)
-      ActualArguments.new(positionals, splat_flags, keywords, @block)
+      keywords, keywords_omittable = build_keyword_args(genv, changes, node)
+      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, activation_required)
     end
 
     def accept_actual_arguments(genv, changes, a_args)
+      changes.add_edge(genv, Source.new(genv.true_type), @activation)
+
       if a_args.splat_flags.any?
         start_rest = [a_args.splat_flags.index(true), @req_positionals.size + @opt_positionals.size].min
         end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @post_positionals.size].max
@@ -149,7 +302,7 @@ module TypeProf::Core
           end
         end
 
-        @opt_positional_elems.each_with_index do |elem_vtx, i|
+        @opt_positionals.each_with_index do |elem_vtx, i|
           i += @req_positionals.size
           if i < start_rest
             changes.add_edge(genv, a_args.positionals[i], elem_vtx)
@@ -171,6 +324,12 @@ module TypeProf::Core
           end
         end
 
+        if @rest_positionals
+          rest_vtxs.each do |vtx|
+            changes.add_edge(genv, vtx, @rest_positionals)
+          end
+        end
+
       else
         @req_positionals.each_with_index do |f_vtx, i|
           changes.add_edge(genv, a_args.positionals[i], f_vtx)
@@ -184,11 +343,17 @@ module TypeProf::Core
         start_rest = @req_positionals.size
         end_rest = a_args.positionals.size - @post_positionals.size
         i = 0
-        while i < @opt_positional_elems.size && start_rest < end_rest
-          changes.add_edge(genv, a_args.positionals[start_rest], @opt_positional_elems[i])
+        while i < @opt_positionals.size && start_rest < end_rest
+          changes.add_edge(genv, a_args.positionals[start_rest], @opt_positionals[i])
           i += 1
           start_rest += 1
         end
+
+        if @rest_positionals
+          start_rest.upto(end_rest - 1) do |i|
+            changes.add_edge(genv, a_args.positionals[i], @rest_positionals)
+          end
+        end
       end
 
       changes.add_edge(genv, a_args.block, @block) if @block && a_args.block
@@ -222,8 +387,11 @@ module TypeProf::Core
     private
 
     def build_keyword_args(genv, changes, node)
-      return nil if @req_keyword_pairs.empty? && @opt_keyword_pairs.empty? && !@rest_keywords
-      return @rest_keywords if @req_keyword_pairs.empty? && @opt_keyword_pairs.empty?
+      opt_keyword_pairs = @opt_keyword_pairs
+
+      if @req_keyword_pairs.empty? && opt_keyword_pairs.empty?
+        return @rest_keywords, !!@rest_keywords
+      end
 
       unified_key = Vertex.new(node)
       unified_val = Vertex.new(node)
@@ -235,18 +403,22 @@ module TypeProf::Core
         literal_pairs[name] = vtx
       end
 
-      @opt_keyword_pairs.each do |name, vtx|
+      opt_keyword_pairs.each do |name, vtx|
         changes.add_edge(genv, Source.new(Type::Symbol.new(genv, name)), unified_key)
         changes.add_edge(genv, vtx, unified_val)
+        literal_pairs[name] = vtx
       end
 
       base_hash_type = genv.gen_hash_type(unified_key, unified_val)
       changes.add_hash_splat_box(genv, @rest_keywords, unified_key, unified_val) if @rest_keywords
 
       if literal_pairs.empty?
-        Source.new(base_hash_type)
+        [Source.new(base_hash_type), false]
+      elsif @rest_keywords
+        fallback = Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
+        [changes.add_keyword_merge_box(genv, @rest_keywords, literal_pairs, fallback).ret, false]
       else
-        Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
+        [Source.new(Type::Record.new(genv, literal_pairs, base_hash_type)), false]
       end
     end
   end

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

@@ -9,6 +9,8 @@ module TypeProf::Core
       @include_defs = Set.empty
       @prepend_decls = []
       @prepend_defs = []
+      @extend_decls = Set.empty
+      @extend_defs = Set.empty
 
       # `class Foo = Bar` / `module Foo = Bar` declarations attached to this entity.
       # Maps an alias decl to the target ModuleEntity at the time of registration.
@@ -23,6 +25,7 @@ module TypeProf::Core
       @self_types = {}
       @included_modules = {}
       @prepended_modules = {}
+      @extended_modules = {}
       @basic_object = @cpath == [:BasicObject]
 
       # child modules (subclasses and all modules that include me)
@@ -57,6 +60,7 @@ module TypeProf::Core
     attr_reader :self_types
     attr_reader :included_modules
     attr_reader :prepended_modules
+    attr_reader :extended_modules
     attr_reader :child_modules
 
     attr_reader :superclass_type_args
@@ -219,6 +223,26 @@ module TypeProf::Core
       genv.add_static_eval_queue(:parent_modules_changed, self)
     end
 
+    def add_extend_decl(genv, node)
+      @extend_decls << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_extend_decl(genv, node)
+      @extend_decls.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def add_extend_def(genv, node)
+      @extend_defs << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_extend_def(genv, node)
+      @extend_defs.delete(node) || raise
+      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)
@@ -285,7 +309,8 @@ module TypeProf::Core
           when AST::ModuleNode
             return nil
           when AST::StructNewNode
-            return []  # inherits from Object (Struct < Object)
+            base_cpath = mdef.struct_base_cpath
+            return base_cpath == @cpath ? [] : base_cpath
           else
             raise
           end
@@ -396,6 +421,30 @@ module TypeProf::Core
           any_updated = true
         end
       end
+      @extend_decls.each do |edecl|
+        new_parent_cpath = edecl.static_ret.last.cpath
+        new_parent, updated = update_parent(genv, edecl, @extended_modules[edecl], new_parent_cpath)
+        if updated
+          if new_parent
+            @extended_modules[edecl] = new_parent
+          else
+            @extended_modules.delete(edecl) || raise
+          end
+          any_updated = true
+        end
+      end
+      @extend_defs.each do |edef|
+        new_parent_cpath = edef.static_ret ? edef.static_ret.cpath : nil
+        new_parent, updated = update_parent(genv, edef, @extended_modules[edef], new_parent_cpath)
+        if updated
+          if new_parent
+            @extended_modules[edef] = new_parent
+          else
+            @extended_modules.delete(edef) || 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
@@ -414,6 +463,15 @@ module TypeProf::Core
           true
         end
       end
+      @extended_modules.delete_if do |origin, old_mod|
+        if @extend_decls.include?(origin) || @extend_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|
@@ -424,6 +482,8 @@ module TypeProf::Core
     end
 
     def on_ancestors_updated(genv, base_mod)
+      # `include` and `extend` can form a cycle in valid Ruby
+      return if base_mod == self
       @child_modules.each_key {|child_mod| child_mod.on_ancestors_updated(genv, base_mod || self) }
       @static_reads.each_value do |static_reads|
         static_reads.each do |static_read|

data/lib/typeprof/core/env.rb

@@ -80,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
@@ -95,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
@@ -106,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
@@ -352,7 +364,7 @@ module TypeProf::Core
   end
 
   class LocalEnv
-    def initialize(file_context, cref, locals, return_boxes, forward_args = nil)
+    def initialize(file_context, cref, locals, return_boxes, forward_args = nil, sig_type_params: nil)
       @file_context = file_context
       @cref = cref
       @locals = locals
@@ -362,9 +374,11 @@ module TypeProf::Core
       @ivar_narrowings = {}
       @strict_const_scope = false
       @forward_args = forward_args
+      # [cpath, names] of the type parameters of the enclosing RBS declaration
+      @sig_type_params = sig_type_params
     end
 
-    attr_reader :file_context, :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, :sig_type_params
     attr_accessor :module_function, :forward_args
 
     def path = @file_context&.path