typeprof 0.31.0 → 0.32.0

data/lib/typeprof/core/builtin.rb

@@ -69,6 +69,20 @@ module TypeProf::Core
         else
           false
         end
+      elsif a_args.positionals.size == 3
+        # ary[start, len] = val
+        # Use SplatBox to extract element types from the assigned value
+        elem_vtx = case ty
+        when Type::Array
+          ty.get_elem(@genv)
+        when Type::Instance
+          ty.mod == @genv.mod_ary ? ty.args[0] : nil
+        end
+        return false unless elem_vtx
+        val = a_args.positionals[2]
+        splat_ret = changes.add_splat_box(@genv, val).ret
+        changes.add_edge(@genv, splat_ret, elem_vtx)
+        true
       else
         false
       end
@@ -90,7 +104,7 @@ module TypeProf::Core
     def hash_aref(changes, node, ty, a_args, ret)
       if a_args.positionals.size == 1
         case ty
-        when Type::Hash, Type::Record
+        when Type::Hash
           idx = node.positional_args[0]
           idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
           value = ty.get_value(idx)
@@ -101,6 +115,20 @@ module TypeProf::Core
             changes.add_edge(@genv, Source.new(), ret)
           end
           true
+        when Type::Record
+          idx = node.positional_args[0]
+          idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
+          value = ty.get_value(idx)
+          if value
+            changes.add_edge(@genv, value, ret)
+          else
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          # Symbol variable access - add nil possibility
+          if idx.nil?
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          true
         else
           false
         end
@@ -125,6 +153,15 @@ module TypeProf::Core
           end
           changes.add_edge(@genv, val, ret)
           true
+        when Type::Record
+          val = a_args.positionals[1]
+          idx = node.positional_args[0]
+          if idx.is_a?(AST::SymbolNode)
+            field_vtx = ty.get_value(idx.lit)
+            changes.add_edge(@genv, val, field_vtx) if field_vtx
+          end
+          changes.add_edge(@genv, val, ret)
+          true
         else
           false
         end
@@ -133,19 +170,154 @@ module TypeProf::Core
       end
     end
 
+    def object_method(changes, node, ty, a_args, ret)
+      if a_args.positionals.size == 1
+        sym_node = node.positional_args[0]
+        if sym_node.is_a?(AST::SymbolNode)
+          method_ty = Type::Method.new(@genv, ty, sym_node.lit)
+          changes.add_edge(@genv, Source.new(method_ty), ret)
+          return true
+        end
+      end
+      false
+    end
+
+    def method_call(changes, node, ty, a_args, ret)
+      case ty
+      when Type::Method
+        recv = Source.new(ty.recv_ty)
+        box = changes.add_method_call_box(@genv, recv, ty.mid, a_args, false)
+        changes.add_edge(@genv, box.ret, ret)
+        true
+      else
+        false
+      end
+    end
+
+    def kernel_send(changes, node, ty, a_args, ret)
+      return false if a_args.positionals.empty?
+
+      if a_args.splat_flags[0]
+        # send(*array) case: extract method name and args from array elements
+        splat_vtx = a_args.positionals[0]
+        changes.add_edge(@genv, splat_vtx, changes.target)
+
+        rest_positionals = a_args.positionals[1..]
+        rest_splat_flags = a_args.splat_flags[1..]
+
+        splat_vtx.each_type do |ary_ty|
+          next unless ary_ty.is_a?(Type::Array)
+
+          if ary_ty.elems && ary_ty.elems.size >= 1
+            # Tuple: use per-element precision
+            method_name_vtx = ary_ty.elems[0]
+            changes.add_edge(@genv, method_name_vtx, changes.target)
+
+            elem_args = ary_ty.elems[1..] + rest_positionals
+            elem_flags = ::Array.new(ary_ty.elems.size - 1, false) + rest_splat_flags
+            send_a_args = ActualArguments.new(elem_args, elem_flags, a_args.keywords, a_args.block)
+
+            method_name_vtx.each_type do |sym_ty|
+              if sym_ty.is_a?(Type::Symbol)
+                recv = Source.new(ty)
+                box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+                changes.add_edge(@genv, box.ret, ret)
+              end
+            end
+          else
+            # Non-tuple array: use unified element type for method name
+            elem_vtx = ary_ty.get_elem(@genv)
+            next unless elem_vtx
+            changes.add_edge(@genv, elem_vtx, changes.target)
+
+            send_a_args = ActualArguments.new(rest_positionals, rest_splat_flags, a_args.keywords, a_args.block)
+
+            elem_vtx.each_type do |sym_ty|
+              if sym_ty.is_a?(Type::Symbol)
+                recv = Source.new(ty)
+                box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+                changes.add_edge(@genv, box.ret, ret)
+              end
+            end
+          end
+        end
+      else
+        # send(:sym, ...) case
+        changes.add_edge(@genv, a_args.positionals[0], changes.target)
+        send_a_args = ActualArguments.new(
+          a_args.positionals[1..],
+          a_args.splat_flags[1..],
+          a_args.keywords,
+          a_args.block,
+        )
+        a_args.positionals[0].each_type do |sym_ty|
+          if sym_ty.is_a?(Type::Symbol)
+            recv = Source.new(ty)
+            box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+            changes.add_edge(@genv, box.ret, ret)
+          end
+        end
+      end
+      true
+    end
+
+    def kernel_array(changes, node, ty, a_args, ret)
+      return false unless a_args.positionals.size == 1
+
+      arg_vtx = a_args.positionals[0]
+      elem_vtx = Vertex.new(node)
+      handled = false
+      needs_elem_wrap = false
+
+      arg_vtx.each_type do |arg_ty|
+        handled = true
+        case arg_ty
+        when Type::Instance
+          if arg_ty.mod == @genv.mod_range && arg_ty.args && !arg_ty.args.empty?
+            changes.add_edge(@genv, arg_ty.args[0], elem_vtx)
+            needs_elem_wrap = true
+          elsif arg_ty.mod == @genv.mod_ary
+            changes.add_edge(@genv, Source.new(arg_ty), ret)
+          else
+            changes.add_edge(@genv, Source.new(arg_ty), elem_vtx)
+            needs_elem_wrap = true
+          end
+        when Type::Array
+          changes.add_edge(@genv, Source.new(arg_ty), ret)
+        else
+          changes.add_edge(@genv, Source.new(arg_ty), elem_vtx)
+          needs_elem_wrap = true
+        end
+      end
+
+      return false unless handled
+
+      if needs_elem_wrap
+        ary_ty = @genv.gen_ary_type(elem_vtx)
+        changes.add_edge(@genv, Source.new(ary_ty), ret)
+      end
+      true
+    end
+
     def deploy
-      {
-        class_new: [[:Class], false, :new],
-        object_class: [[:Object], false, :class],
-        proc_call: [[:Proc], false, :call],
-        array_aref: [[:Array], false, :[]],
-        array_aset: [[:Array], false, :[]=],
-        array_push: [[:Array], false, :<<],
-        hash_aref: [[:Hash], false, :[]],
-        hash_aset: [[:Hash], false, :[]=],
-      }.each do |key, (cpath, singleton, mid)|
+      [
+        [method(:class_new), [:Class], false, :new],
+        [method(:object_class), [:Object], false, :class],
+        [method(:proc_call), [:Proc], false, :call],
+        [method(:array_aref), [:Array], false, :[]],
+        [method(:array_aset), [:Array], false, :[]=],
+        [method(:array_push), [:Array], false, :<<],
+        [method(:hash_aref), [:Hash], false, :[]],
+        [method(:hash_aset), [:Hash], false, :[]=],
+        [method(:object_method), [:Kernel], false, :method],
+        [method(:method_call), [:Method], false, :call],
+        [method(:kernel_send), [:BasicObject], false, :__send__],
+        [method(:kernel_send), [:Kernel], false, :public_send],
+        [method(:kernel_send), [:Kernel], false, :send],
+        [method(:kernel_array), [:Kernel], false, :Array],
+      ].each do |builtin, cpath, singleton, mid|
         me = @genv.resolve_method(cpath, singleton, mid)
-        me.builtin = method(key)
+        me.builtin = builtin
       end
     end
   end

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

@@ -41,6 +41,17 @@ 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 get_rest_args(genv, changes, start_rest, end_rest)
       vtxs = []
 
@@ -69,6 +80,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 +95,162 @@ module TypeProf::Core
     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)
+      @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
+    end
+
+    attr_reader :block
+
+    def to_actual_arguments(genv, changes, node)
+      positionals = @req_positionals.dup
+      splat_flags = ::Array.new(positionals.size, false)
+
+      @opt_positionals.each do |arg|
+        positionals << arg
+        splat_flags << true
+      end
+
+      if @rest_positionals
+        positionals << @rest_positionals
+        splat_flags << true
+      end
+
+      @post_positionals.each do |arg|
+        positionals << arg
+        splat_flags << false
+      end
+
+      keywords = build_keyword_args(genv, changes, node)
+      ActualArguments.new(positionals, splat_flags, keywords, @block)
+    end
+
+    def accept_actual_arguments(genv, changes, a_args)
+      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_positional_elems.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
+
+      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_positional_elems.size && start_rest < end_rest
+          changes.add_edge(genv, a_args.positionals[start_rest], @opt_positional_elems[i])
+          i += 1
+          start_rest += 1
+        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)
+      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?
+
+      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)
+      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)
+      else
+        Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
+      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 +264,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,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)