typeprof 0.32.0 → 0.33.1

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

@@ -14,16 +14,20 @@ module TypeProf::Core
         @cpath = AST.resolve_rbs_name(raw_decl.name, lenv)
         # TODO: decl.type_params
         # TODO: decl.super_class.args
+        # TODO?: param.variance, param.unchecked, param.upper_bound
+        @params = raw_decl.type_params.map {|param| param.name }
+        sig_type_params = [@cpath, @params]
+        # The header (default types, self types, and superclass arguments) is
+        # resolved in the outer scope but may refer to the type parameters
+        @header_lenv = LocalEnv.new(@lenv.file_context, lenv.cref, {}, [], sig_type_params:)
         ncref = CRef.new(@cpath, :class, nil, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [], sig_type_params:)
         @members = raw_decl.members.map do |member|
           AST.create_rbs_member(member, nlenv)
         end.compact
-        # TODO?: param.variance, param.unchecked, param.upper_bound
-        @params = raw_decl.type_params.map {|param| param.name }
         @params_default_types = raw_decl.type_params.map do |param|
           ty = param.default_type
-          ty ? AST.create_rbs_type(ty, lenv) : nil
+          ty ? AST.create_rbs_type(ty, @header_lenv) : nil
         end
       end
 
@@ -81,7 +85,7 @@ module TypeProf::Core
           cpath = name.namespace.path + [self_type.name.name]
           toplevel = name.namespace.absolute?
           @self_types << [cpath, toplevel]
-          @self_type_args << self_type.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+          @self_type_args << self_type.args.map {|arg| AST.create_rbs_type(arg, @header_lenv) }
         end
       end
 
@@ -138,7 +142,7 @@ module TypeProf::Core
           name = superclass.name
           @superclass_cpath = name.namespace.path + [name.name]
           @superclass_toplevel = name.namespace.absolute?
-          @superclass_args = superclass.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+          @superclass_args = superclass.args.map {|arg| AST.create_rbs_type(arg, @header_lenv) }
         else
           @superclass_cpath = nil
           @superclass_toplevel = nil
@@ -190,7 +194,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 +204,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 +322,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
@@ -848,18 +883,32 @@ module TypeProf::Core
 
       def attrs = { var: }
 
+      # A reopened declaration may rename the type parameters (e.g., `Enumerable[E]`
+      # and `Enumerable[Elem]`), but the subst is keyed by the names of the module
+      # entity, so fall back to matching them by position
+      def resolve_var(genv, subst)
+        decl_cpath, decl_params = @lenv.sig_type_params
+        return subst[@var] unless decl_params
+        idx = decl_params.index(@var)
+        return subst[@var] unless idx
+        subst[genv.resolve_cpath(decl_cpath).type_params.keys[idx]]
+      end
+
       def covariant_vertex0(genv, changes, vtx, subst)
-        raise "unknown type variable: #{ @var }" unless subst[@var]
-        changes.add_edge(genv, subst[@var], vtx)
+        var_vtx = resolve_var(genv, subst)
+        raise "unknown type variable: #{ @var }" unless var_vtx
+        changes.add_edge(genv, var_vtx, vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        raise "unknown type variable: #{ @var }" unless subst[@var]
-        changes.add_edge(genv, Source.new(Type::Var.new(genv, @var, subst[@var])), vtx)
+        var_vtx = resolve_var(genv, subst)
+        raise "unknown type variable: #{ @var }" unless var_vtx
+        changes.add_edge(genv, Source.new(Type::Var.new(genv, @var, var_vtx)), vtx)
       end
 
       def typecheck(genv, changes, vtx, subst)
-        changes.add_edge(genv, vtx.new_vertex(genv, self), subst[@var]) unless vtx == subst[@var]
+        var_vtx = resolve_var(genv, subst)
+        changes.add_edge(genv, vtx.new_vertex(genv, self), var_vtx) unless vtx == var_vtx
         true
       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

@@ -1,14 +1,24 @@
 module TypeProf::Core
   class AST
     def self.parse_rb(path, src, position_encoding)
-      result = Prism.parse(src)
+      build_rb(path, Prism.parse(src), position_encoding)
+    end
+
+    # This needs the comments and the Prism::Source, which a ParseResult has but a
+    # node does not.
+    def self.build_rb(path, result, position_encoding)
+      unless result.is_a?(Prism::ParseResult)
+        raise ArgumentError, "expected Prism::ParseResult, got #{ result.class }"
+      end
 
       return nil unless result.errors.empty?
 
       # comments, errors, magic_comments
       raw_scope = result.value
 
-      raise unless raw_scope.type == :program_node
+      unless raw_scope.is_a?(Prism::ProgramNode)
+        raise ArgumentError, "expected Prism::ProgramNode, got #{ raw_scope.class }"
+      end
 
       prism_source = result.source
       file_context = FileContext.new(path, position_encoding, prism_source, result.comments)
@@ -283,6 +293,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 +472,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