typeprof 0.32.0 → 0.33.0

data/lib/typeprof/core/ast/misc.rb

@@ -256,9 +256,20 @@ module TypeProf::Core
         vtx = @expr.install(genv)
 
         a_args = ActualArguments.new([], [], nil, nil)
-        to_a_vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false, suppress_errors: true).ret
-
-        @changes.add_splat_box(genv, to_a_vtx, nil, vtx).ret
+        # Receiver types with no `to_a` are collected here, so that each union
+        # member can independently fall back to wrapping itself as `[x]`.
+        unresolved_recv = Vertex.new(self)
+        to_a_box = @changes.add_method_call_box(
+          genv,
+          vtx,
+          :to_a,
+          a_args,
+          false,
+          suppress_errors: true,
+          unresolved_recv: unresolved_recv,
+        )
+
+        @changes.add_splat_box(genv, to_a_box.ret, nil, unresolved_recv).ret
       end
     end
 
@@ -332,8 +343,7 @@ module TypeProf::Core
       def subnodes = { value:, pat: }
 
       def install0(genv)
-        @value.install(genv)
-        @pat.install(genv)
+        @pat.install_pattern(genv, @value.install(genv))
         Source.new(genv.nil_type)
       end
     end
@@ -350,8 +360,7 @@ module TypeProf::Core
       def subnodes = { value:, pat: }
 
       def install0(genv)
-        @value.install(genv)
-        @pat.install(genv)
+        @pat.install_pattern(genv, @value.install(genv))
         Source.new(genv.true_type, genv.false_type)
       end
     end

data/lib/typeprof/core/ast/module.rb

@@ -18,11 +18,15 @@ module TypeProf::Core
           @body = nil
         end
 
-        @cname_code_range = meta ? nil : lenv.code_range_from_node(raw_node.constant_path)
+        @cname_code_range_loc = meta ? nil : raw_node.constant_path
         @mod_cdef = nil
       end
 
-      attr_reader :tbl, :cpath, :static_cpath, :cname_code_range, :body
+      attr_reader :tbl, :cpath, :static_cpath, :body
+
+      def cname_code_range
+        @cname_code_range ||= @lenv.code_range_from_node(@cname_code_range_loc) if @cname_code_range_loc
+      end
 
       def subnodes = { cpath:, body: }
       def attrs = { static_cpath:, tbl: }

data/lib/typeprof/core/ast/pattern.rb

@@ -22,14 +22,19 @@ module TypeProf::Core
       def attrs = { rest: }
       def subnodes = { requireds:, rest_pattern:, posts: }
 
-      def install0(genv)
-        @requireds.each do |pat|
-          pat.install(genv)
+      def install_pattern0(genv, subject)
+        @requireds.each_with_index do |pat, i|
+          pat.install_pattern(genv, @changes.add_splat_box(genv, subject, i).ret)
+        end
+        if @rest_pattern
+          elem = @changes.add_splat_box(genv, subject).ret
+          @rest_pattern.install_pattern(genv, Source.new(genv.gen_ary_type(elem)))
         end
-        @rest_pattern.install(genv) if @rest_pattern
         @posts.each do |pat|
-          pat.install(genv)
+          # TODO: precise indices for post elements (those after `*rest`)
+          pat.install_pattern(genv, @changes.add_splat_box(genv, subject).ret)
         end
+        subject
       end
     end
 
@@ -39,7 +44,14 @@ module TypeProf::Core
         @keys = raw_node.elements.map {|raw_assoc| raw_assoc.key.value.to_sym }
         @values = raw_node.elements.map {|raw_assoc| AST.create_pattern_node(raw_assoc.value, lenv) }
         @rest = !!raw_node.rest
-        @rest_pattern = raw_node.rest && raw_node.rest.value ? AST.create_pattern_node(raw_node.rest.value, lenv) : nil
+        @rest_pattern = case raw_node.rest
+                        when Prism::AssocSplatNode
+                          AST.create_pattern_node(raw_node.rest.value, lenv) if raw_node.rest.value
+                        when Prism::NoKeywordsParameterNode, nil
+                          nil
+                        else
+                          raise
+                        end
       end
 
       attr_reader :keys, :values, :rest, :rest_pattern
@@ -47,32 +59,37 @@ module TypeProf::Core
       def attrs = { keys:, rest: }
       def subnodes = { values:, rest_pattern: }
 
-      def install0(genv)
+      def install_pattern0(genv, subject)
+        # TODO: extract each key's value type from `subject` (captures stay untyped for now)
         @values.each do |pat|
-          pat.install(genv)
+          pat.install_pattern(genv, Vertex.new(self))
         end
-        @rest_pattern.install(genv) if @rest_pattern
+        @rest_pattern.install_pattern(genv, Vertex.new(self)) if @rest_pattern
+        subject
       end
     end
 
     class FindPatternNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        @left = raw_node.left ? AST.create_pattern_node(raw_node.left.expression, lenv) : nil
+        @left = raw_node.left.expression ? AST.create_pattern_node(raw_node.left.expression, lenv) : nil
         @requireds = raw_node.requireds.map {|raw_elem| AST.create_pattern_node(raw_elem, lenv) }
-        @right = raw_node.right ? AST.create_pattern_node(raw_node.right.expression, lenv) : nil
+        @right = raw_node.right.expression ? AST.create_pattern_node(raw_node.right.expression, lenv) : nil
       end
 
       attr_reader :left, :requireds, :right
 
       def subnodes = { left:, requireds:, right: }
 
-      def install0(genv)
-        @left.install(genv) if @left
+      def install_pattern0(genv, subject)
+        elem = @changes.add_splat_box(genv, subject).ret
+        rest_ary = Source.new(genv.gen_ary_type(elem))
+        @left.install_pattern(genv, rest_ary) if @left
         @requireds.each do |pat|
-          pat.install(genv)
+          pat.install_pattern(genv, elem)
         end
-        @right.install(genv) if @right
+        @right.install_pattern(genv, rest_ary) if @right
+        subject
       end
     end
 
@@ -87,9 +104,10 @@ module TypeProf::Core
 
       def subnodes = { left:, right: }
 
-      def install0(genv)
-        @left.install(genv)
-        @right.install(genv)
+      def install_pattern0(genv, subject)
+        @left.install_pattern(genv, subject)
+        @right.install_pattern(genv, subject)
+        subject
       end
     end
 
@@ -104,9 +122,18 @@ module TypeProf::Core
 
       def subnodes = { value:, target: }
 
-      def install0(genv)
-        @value.install(genv)
-        @target.install(genv)
+      def install_pattern0(genv, subject)
+        @value.install_pattern(genv, subject)
+        # For `Const => var`, narrow the capture by the class, as `when Const` does
+        narrowed =
+          if @value.is_a?(ConstantReadNode) && @value.static_ret
+            filtered = subject.new_vertex(genv, self)
+            IsAFilter.new(genv, self, filtered, false, @value.static_ret).next_vtx
+          else
+            subject
+          end
+        @target.install_pattern(genv, narrowed)
+        subject
       end
     end
 
@@ -124,9 +151,10 @@ module TypeProf::Core
 
       def subnodes = { cond:, body: }
 
-      def install0(genv)
+      def install_pattern0(genv, subject)
         @cond.install(genv)
-        @body.install(genv)
+        @body.install_pattern(genv, subject)
+        subject
       end
     end
 

data/lib/typeprof/core/ast/sig_decl.rb

@@ -190,7 +190,7 @@ module TypeProf::Core
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
         @mid = raw_decl.name
-        @mid_code_range = lenv.code_range_from_node(raw_decl.location[:name])
+        @mid_code_range_loc = raw_decl.location[:name]
         @singleton = raw_decl.singleton?
         @instance = raw_decl.instance?
         @method_types = OverloadSet.new(raw_decl.overloads.map do |overload|
@@ -200,12 +200,16 @@ module TypeProf::Core
         @overloading = raw_decl.overloading
       end
 
-      attr_reader :mid, :singleton, :instance, :method_types, :overloading, :mid_code_range
+      attr_reader :mid, :singleton, :instance, :method_types, :overloading
+
+      def mid_code_range
+        @mid_code_range ||= @lenv.code_range_from_node(@mid_code_range_loc) if @mid_code_range_loc
+      end
 
       def subnodes = { method_types: @method_types.to_a }
-      def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
+      def attrs = { mid:, singleton:, instance:, overloading: }
 
-      def mname_code_range(_name) = @mid_code_range
+      def mname_code_range(_name) = mid_code_range
 
       def install0(genv)
         [[@singleton, true], [@instance, false]].each do |enabled, singleton|
@@ -314,6 +318,55 @@ module TypeProf::Core
       end
     end
 
+    class SigExtendNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        name = raw_decl.name
+        @cpath = name.namespace.path + [name.name]
+        @toplevel = name.namespace.absolute?
+        @args = raw_decl.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+      end
+
+      attr_reader :cpath, :toplevel, :args
+      def subnodes = { args: }
+      def attrs = { cpath:, toplevel: }
+
+      def define0(genv)
+        @args.each {|arg| arg.define(genv) }
+        const_reads = []
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, true)
+        const_reads << const_read
+        @cpath[1..].each do |cname|
+          const_read = ScopedConstRead.new(cname, const_read, true)
+          const_reads << const_read
+        end
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        const_read.followers << mod
+        mod.add_extend_decl(genv, self)
+        const_reads
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.add_extend_decl(genv, self)
+        mod.remove_extend_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.remove_extend_decl(genv, self)
+        @static_ret.each do |const_read|
+          const_read.destroy(genv)
+        end
+        @args.each {|arg| arg.undefine(genv) }
+      end
+
+      def install0(genv)
+        Source.new
+      end
+    end
+
     class SigAliasNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)

data/lib/typeprof/core/ast/sig_type.rb

@@ -23,6 +23,9 @@ module TypeProf::Core
           if f_mod.module?
             return true if typecheck_for_prepended_modules(genv, changes, ty, f_mod, f_args, subst)
             return true if typecheck_for_included_modules(genv, changes, ty, f_mod, f_args, subst)
+            if ty.is_a?(Type::Singleton)
+              return true if typecheck_for_extended_modules(genv, changes, ty, f_mod, f_args, subst)
+            end
           end
 
           ty = genv.get_superclass_type(ty, changes, {})
@@ -81,6 +84,32 @@ module TypeProf::Core
       return false
     end
 
+    def self.typecheck_for_extended_modules(genv, changes, a_ty, f_mod, f_args, subst)
+      a_ty.mod.extended_modules.each do |ext_decl, ext_mod|
+        if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
+          ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, {}, a_ty)
+        else
+          type_params = ext_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          ext_ty = Type::Instance.new(genv, ext_mod, type_params)
+        end
+        if ext_ty.mod == f_mod
+          args_all_match = true
+          f_args.zip(ext_ty.args) do |f_arg_node, a_arg_vtx|
+            unless f_arg_node.typecheck(genv, changes, a_arg_vtx, subst)
+              args_all_match = false
+              break
+            end
+          end
+          return true if args_all_match
+        end
+        changes.add_depended_superclass(ext_ty.mod)
+
+        # The extended module may itself include other modules
+        return true if typecheck_for_included_modules(genv, changes, ext_ty, f_mod, f_args, subst)
+      end
+      return false
+    end
+
     class SigFuncType < Node
       def initialize(raw_decl, raw_type_params, raw_block, lenv)
         super(raw_decl, lenv)
@@ -465,7 +494,13 @@ module TypeProf::Core
           decl = tae.decls.each {|decl| break decl }
           subst0 = subst.dup
           decl.params.zip(@args) do |param, arg|
-            subst0[param] = arg.covariant_vertex(genv, changes, subst0)
+            if arg.is_a?(SigTyVarNode) && subst[arg.var]
+              # Share the vertex so that the types inferred in the alias body flow
+              # back into the variable, which makes `U` of `(array[U])` inferrable
+              subst0[param] = subst[arg.var]
+            else
+              subst0[param] = arg.covariant_vertex(genv, changes, subst0)
+            end
           end
           tae.type.typecheck(genv, changes, vtx, subst0)
         end

data/lib/typeprof/core/ast/variable.rb

@@ -63,6 +63,12 @@ module TypeProf::Core
         val
       end
 
+      def install_pattern0(genv, subject)
+        install0(genv)
+        @changes.add_edge(genv, subject, @rhs.ret)
+        subject
+      end
+
       def retrieve_at(pos, &blk)
         yield self if @var_code_range && @var_code_range.include?(pos)
         super(pos, &blk)

data/lib/typeprof/core/ast.rb

@@ -283,6 +283,8 @@ module TypeProf::Core
           case raw_node.name
           when :include
             return IncludeMetaNode.new(raw_node, lenv)
+          when :extend
+            return ExtendMetaNode.new(raw_node, lenv)
           when :attr_reader
             return AttrReaderMetaNode.new(raw_node, lenv)
           when :attr_writer
@@ -460,6 +462,7 @@ module TypeProf::Core
       when RBS::AST::Members::Prepend
         SigPrependNode.new(raw_decl, lenv)
       when RBS::AST::Members::Extend
+        SigExtendNode.new(raw_decl, lenv)
       when RBS::AST::Members::Public
       when RBS::AST::Members::Private
       when RBS::AST::Members::Alias

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