typeprof 0.31.1 → 0.33.0

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

@@ -41,6 +41,40 @@ module TypeProf::Core
       ActualArguments.new(positionals, splat_flags, keywords, block)
     end
 
+    def with_keywords_as_last_positional_hash
+      return self unless @keywords
+
+      ActualArguments.new(
+        @positionals + [@keywords],
+        @splat_flags + [false],
+        nil,
+        @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 = []
 
@@ -69,6 +103,9 @@ module TypeProf::Core
         case ty
         when Type::Hash
           changes.add_edge(genv, ty.get_value(name), vtx)
+        when Type::Record
+          field_vtx = ty.get_value(name)
+          changes.add_edge(genv, field_vtx, vtx) if field_vtx
         when Type::Instance
           if ty.mod == genv.mod_hash
             changes.add_edge(genv, ty.args[1], vtx)
@@ -81,6 +118,311 @@ 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, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation)
+      @req_positionals = req_positionals
+      @opt_positionals = opt_positionals
+      @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
+
+    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 |elem_vtx|
+        positionals << Source.new(genv.gen_ary_type(elem_vtx))
+        splat_flags << true
+        positionals_omittable << true
+      end
+
+      if @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, 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
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+
+        @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)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, elem_vtx)
+            end
+          end
+        end
+
+        @post_positionals.each_with_index do |f_vtx, i|
+          i += a_args.positionals.size - @post_positionals.size
+          if end_rest <= i
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          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)
+        end
+
+        @post_positionals.each_with_index do |f_vtx, i|
+          i -= @post_positionals.size
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+
+        start_rest = @req_positionals.size
+        end_rest = a_args.positionals.size - @post_positionals.size
+        i = 0
+        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
+
+      return unless a_args.keywords
+
+      @req_keyword_pairs.each do |name, f_vtx|
+        changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+      end
+
+      @opt_keyword_pairs.each do |name, f_vtx|
+        changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+      end
+
+      if @rest_keywords
+        named_keys = @req_keyword_pairs.map(&:first) + @opt_keyword_pairs.map(&:first)
+        a_args.keywords.each_type do |kw_ty|
+          case kw_ty
+          when Type::Record
+            rest_fields = kw_ty.fields.reject {|key, _| named_keys.include?(key) }
+            base = kw_ty.base_type(genv)
+            rest_record = Type::Record.new(genv, rest_fields, base)
+            changes.add_edge(genv, Source.new(rest_record), @rest_keywords)
+          when Type::Hash, Type::Instance
+            changes.add_edge(genv, Source.new(kw_ty), @rest_keywords)
+          end
+        end
+      end
+    end
+
+    private
+
+    def build_keyword_args(genv, changes, node)
+      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)
+      literal_pairs = {}
+
+      @req_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
+
+      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), 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)), false]
+      end
+    end
+  end
+
   class Block
     #: (AST::CallBaseNode, Vertex, Array[Vertex], Array[EscapeBox]) -> void
     def initialize(node, f_ary_arg, f_args, next_boxes)
@@ -94,12 +436,7 @@ module TypeProf::Core
 
     def accept_args(genv, changes, caller_positionals)
       if caller_positionals.size == 1 && @f_args.size >= 2
-        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
+        changes.add_edge(genv, caller_positionals[0], @f_ary_arg)
       else
         caller_positionals.zip(@f_args) do |a_arg, f_arg|
           changes.add_edge(genv, a_arg, f_arg) if f_arg

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,12 +3,19 @@ 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 = []
+      @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.
+      @alias_decls = {}
+      @alias_target = nil
 
       @inner_modules = {}
       @outer_module = outer_module
@@ -18,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)
@@ -25,7 +33,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 +42,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
@@ -50,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
@@ -79,7 +90,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 +126,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 +145,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 +164,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 +187,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)
@@ -196,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)
@@ -237,7 +284,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 +308,9 @@ module TypeProf::Core
             next
           when AST::ModuleNode
             return nil
+          when AST::StructNewNode
+            base_cpath = mdef.struct_base_cpath
+            return base_cpath == @cpath ? [] : base_cpath
           else
             raise
           end
@@ -371,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
@@ -389,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|
@@ -399,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|
@@ -436,6 +521,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