typeprof 0.30.1 → 0.31.0

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

@@ -1,5 +1,83 @@
 module TypeProf::Core
   class AST
+    def self.typecheck_for_module(genv, changes, f_mod, f_args, a_vtx, subst)
+      changes.add_edge(genv, a_vtx, changes.target)
+      a_vtx.each_type do |ty|
+        ty = ty.base_type(genv)
+        while ty
+          if ty.mod == f_mod && ty.is_a?(Type::Instance)
+            args_all_match = true
+            f_args.zip(ty.args) do |f_arg_node, a_arg_ty|
+              unless f_arg_node.typecheck(genv, changes, a_arg_ty, subst)
+                args_all_match = false
+                break
+              end
+            end
+            return true if args_all_match
+          end
+          changes.add_depended_superclass(ty.mod)
+
+          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)
+          end
+
+          ty = genv.get_superclass_type(ty, changes, {})
+        end
+      end
+      return false
+    end
+
+    def self.typecheck_for_prepended_modules(genv, changes, a_ty, f_mod, f_args, subst)
+      a_ty.mod.prepended_modules.each do |prep_decl, prep_mod|
+        if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
+          prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, {}, a_ty)
+        else
+          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          prep_ty = Type::Instance.new(genv, prep_mod, type_params)
+        end
+        if prep_ty.mod == f_mod
+          args_all_match = true
+          f_args.zip(prep_ty.args) do |f_arg_node, a_arg_ty|
+            unless f_arg_node.typecheck(genv, changes, a_arg_ty, subst)
+              args_all_match = false
+              break
+            end
+          end
+          return true if args_all_match
+        end
+        changes.add_depended_superclass(prep_ty.mod)
+
+        return true if typecheck_for_prepended_modules(genv, changes, prep_ty, f_mod, f_args, subst)
+      end
+      return false
+    end
+
+    def self.typecheck_for_included_modules(genv, changes, a_ty, f_mod, f_args, subst)
+      a_ty.mod.included_modules.each do |inc_decl, inc_mod|
+        if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
+          inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, {}, a_ty)
+        else
+          type_params = inc_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          inc_ty = Type::Instance.new(genv, inc_mod, type_params)
+        end
+        if inc_ty.mod == f_mod
+          args_all_match = true
+          f_args.zip(inc_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(inc_ty.mod)
+
+        return true if typecheck_for_included_modules(genv, changes, inc_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)
@@ -101,6 +179,14 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(genv.true_type, genv.false_type), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.each_type do |ty|
+          return false unless ty == genv.true_type || ty == genv.false_type
+        end
+        true
+      end
+
       def show
         "bool"
       end
@@ -115,6 +201,14 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(genv.nil_type), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.each_type do |ty|
+          return false unless ty == genv.nil_type
+        end
+        true
+      end
+
       def show
         "nil"
       end
@@ -129,6 +223,10 @@ module TypeProf::Core
         changes.add_edge(genv, subst[:"*self"], vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true # TODO: check self type
+      end
+
       def show
         "self"
       end
@@ -143,6 +241,10 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(genv.obj_type), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true
+      end
+
       def show
         "void"
       end
@@ -156,6 +258,10 @@ module TypeProf::Core
         #Source.new(genv.obj_type).add_edge(genv, vtx) # TODO
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true
+      end
+
       def show
         "untyped"
       end
@@ -170,6 +276,10 @@ module TypeProf::Core
         # TODO
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true
+      end
+
       def show
         "top"
       end
@@ -184,6 +294,11 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(Type::Bot.new(genv)), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.types.empty?
+      end
+
       def show
         "bot"
       end
@@ -198,6 +313,10 @@ module TypeProf::Core
         changes.add_edge(genv, subst[:"*instance"], vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true # TODO: implement
+      end
+
       def show
         "instance"
       end
@@ -212,6 +331,10 @@ module TypeProf::Core
         changes.add_edge(genv, subst[:"*class"], vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        true # TODO: implement
+      end
+
       def show
         "class"
       end
@@ -236,13 +359,13 @@ module TypeProf::Core
 
         static_reads = []
         if @cpath.empty?
-          static_reads << BaseTypeAliasRead.new(genv, @name, @toplevel ? CRef::Toplevel : @lenv.cref)
+          static_reads << BaseTypeAliasRead.new(genv, @name, @toplevel ? CRef::Toplevel : @lenv.cref, false)
         else
-          static_reads << BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref)
+          static_reads << BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
           @cpath[1..].each do |cname|
-            static_reads << ScopedConstRead.new(cname, static_reads.last)
+            static_reads << ScopedConstRead.new(cname, static_reads.last, false)
           end
-          static_reads << ScopedTypeAliasRead.new(@name, static_reads.last)
+          static_reads << ScopedTypeAliasRead.new(@name, static_reads.last, false)
         end
         static_reads
       end
@@ -258,9 +381,24 @@ module TypeProf::Core
         changes.add_depended_static_read(@static_ret.last)
         tae = @static_ret.last.type_alias_entity
         if tae && tae.exist?
+          # Check for recursive expansion
+          expansion_key = [@cpath, @name]
+          subst[:__expansion_stack__] ||= []
+
+          if subst[:__expansion_stack__].include?(expansion_key)
+            # Recursive expansion detected: this type alias references itself
+            # Stop expansion here to prevent SystemStackError. The type system
+            # will handle the incomplete expansion gracefully, typically by
+            # treating unresolved recursive references as 'untyped', which
+            # maintains type safety while allowing the program to continue.
+            return
+          end
+
           # need to check tae decls are all consistent?
           decl = tae.decls.each {|decl| break decl }
           subst0 = subst.dup
+          subst0[:__expansion_stack__] = subst[:__expansion_stack__].dup + [expansion_key]
+
           # raise if decl.params.size != @args.size # ?
           decl.params.zip(@args) do |param, arg|
             subst0[param] = arg.covariant_vertex(genv, changes, subst0) # passing subst0 is ok?
@@ -273,9 +411,24 @@ module TypeProf::Core
         changes.add_depended_static_read(@static_ret.last)
         tae = @static_ret.last.type_alias_entity
         if tae && tae.exist?
+          # Check for recursive expansion
+          expansion_key = [@cpath, @name]
+          subst[:__expansion_stack__] ||= []
+
+          if subst[:__expansion_stack__].include?(expansion_key)
+            # Recursive expansion detected: this type alias references itself
+            # Stop expansion here to prevent SystemStackError. The type system
+            # will handle the incomplete expansion gracefully, typically by
+            # treating unresolved recursive references as 'untyped', which
+            # maintains type safety while allowing the program to continue.
+            return
+          end
+
           # need to check tae decls are all consistent?
           decl = tae.decls.each {|decl| break decl }
           subst0 = subst.dup
+          subst0[:__expansion_stack__] = subst[:__expansion_stack__].dup + [expansion_key]
+
           # raise if decl.params.size != @args.size # ?
           decl.params.zip(@args) do |param, arg|
             subst0[param] = arg.contravariant_vertex(genv, changes, subst0)
@@ -284,6 +437,20 @@ module TypeProf::Core
         end
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_depended_static_read(@static_ret.last)
+        tae = @static_ret.last.type_alias_entity
+        if tae && tae.exist?
+          # TODO: check for recursive expansion
+          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)
+          end
+          tae.type.typecheck(genv, changes, vtx, subst0)
+        end
+      end
+
       def show
         "(...alias...)"
       end
@@ -311,22 +478,49 @@ module TypeProf::Core
         end
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        @types.each do |type|
+          return true if type.typecheck(genv, changes, vtx, subst)
+        end
+        false
+      end
+
       def show
         @types.map {|ty| ty.show }.join(" | ")
       end
     end
 
     class SigTyIntersectionNode < SigTyNode
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        @types = (raw_decl.types || []).map {|type| AST.create_rbs_type(type, lenv) }
+      end
+
+      attr_reader :types
+
+      def subnodes = { types: }
+
       def covariant_vertex0(genv, changes, vtx, subst)
-        #raise NotImplementedError
+        @types.each do |type|
+          type.covariant_vertex0(genv, changes, vtx, subst)
+        end
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        #raise NotImplementedError
+        @types.each do |type|
+          type.contravariant_vertex0(genv, changes, vtx, subst)
+        end
+      end
+
+      def typecheck(genv, changes, vtx, subst)
+        @types.each do |type|
+          return false unless type.typecheck(genv, changes, vtx, subst)
+        end
+        true
       end
 
       def show
-        "(...intersection...)"
+        @types.map {|ty| ty.show }.join(" & ")
       end
     end
 
@@ -343,11 +537,11 @@ module TypeProf::Core
 
       def define0(genv)
         const_reads = []
-        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
         const_reads << const_read
         unless @cpath.empty?
           @cpath[1..].each do |cname|
-            const_read = ScopedConstRead.new(cname, const_read)
+            const_read = ScopedConstRead.new(cname, const_read, false)
             const_reads << const_read
           end
         end
@@ -378,6 +572,30 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(Type::Singleton.new(genv, mod)), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_depended_static_read(@static_ret.last)
+        cpath = @static_ret.last.cpath
+        return unless cpath
+        f_mod = genv.resolve_cpath(cpath)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.each_type do |ty|
+          case ty
+          when Type::Singleton
+            if f_mod.module?
+              # TODO: implement
+            else
+              a_mod = ty.mod
+              while a_mod
+                return true if a_mod == f_mod
+                changes.add_depended_superclass(a_mod)
+                a_mod = a_mod.superclass
+              end
+            end
+          end
+        end
+        false
+      end
+
       def show
         s = "::#{ @cpath.join("::") }"
         if !@args.empty?
@@ -403,11 +621,11 @@ module TypeProf::Core
       def define0(genv)
         @args.each {|arg| arg.define(genv) }
         const_reads = []
-        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
         const_reads << const_read
         unless @cpath.empty?
           @cpath[1..].each do |cname|
-            const_read = ScopedConstRead.new(cname, const_read)
+            const_read = ScopedConstRead.new(cname, const_read, false)
             const_reads << const_read
           end
         end
@@ -435,16 +653,33 @@ module TypeProf::Core
         cpath = @static_ret.last.cpath
         return unless cpath
         mod = genv.resolve_cpath(cpath)
-        args = @args.map {|arg| arg.contravariant_vertex(genv, changes, subst) }
+        # TODO: report error for wrong type arguments
+        # TODO: support default type args
+        args = mod.type_params.zip(@args).map do |_, arg|
+          arg ? arg.contravariant_vertex(genv, changes, subst) : Source.new
+        end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_depended_static_read(@static_ret.last)
+        cpath = @static_ret.last.cpath
+        return unless cpath
+        f_mod = genv.resolve_cpath(cpath)
+        AST.typecheck_for_module(genv, changes, f_mod, @args, vtx, subst)
+      end
+
       def show
-        s = "::#{ @cpath.join("::") }"
-        if !@args.empty?
-          s << "[...]"
+        cpath = @static_ret.last.cpath
+        if cpath
+          s = "#{ cpath.join("::") }"
+          if !@args.empty?
+            s << "[...]"
+          end
+          s
+        else
+          "(unknown instance)"
         end
-        s
       end
     end
 
@@ -477,22 +712,96 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(Type::Array.new(genv, elems, genv.gen_ary_type(unified_elem))), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.each_type do |ty|
+          case ty
+          when Type::Array
+            next if ty.elems.size != @types.size
+            @types.zip(ty.elems) do |f_ty, a_ty|
+              return false unless f_ty.typecheck(genv, changes, a_ty, subst)
+            end
+            return true
+          when Type::Instance
+            @types.each do |f_ty|
+              return false unless f_ty.typecheck(genv, changes, vtx, subst)
+            end
+            return true
+          end
+        end
+        false
+      end
+
       def show
         "[#{ @types.map {|ty| ty.show }.join(", ") }]"
       end
     end
 
     class SigTyRecordNode < SigTyNode
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        @fields = raw_decl.fields.transform_values { |val| AST.create_rbs_type(val, lenv) }
+      end
+
+      attr_reader :fields
+      def subnodes = { fields: }
+
       def covariant_vertex0(genv, changes, vtx, subst)
-        raise NotImplementedError
+        field_vertices = {}
+        @fields.each do |key, field_node|
+          field_vertices[key] = field_node.covariant_vertex(genv, changes, subst)
+        end
+
+        # Create base Hash type for Record
+        key_vtx = Source.new(genv.symbol_type)
+        # Create union of all field values for the Hash value type
+        val_vtx = changes.new_covariant_vertex(genv, [self, :union])
+        field_vertices.each_value do |field_vtx|
+          changes.add_edge(genv, field_vtx, val_vtx)
+        end
+        base_hash_type = genv.gen_hash_type(key_vtx, val_vtx)
+
+        changes.add_edge(genv, Source.new(Type::Record.new(genv, field_vertices, base_hash_type)), vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        raise NotImplementedError
+        field_vertices = {}
+        @fields.each do |key, field_node|
+          field_vertices[key] = field_node.contravariant_vertex(genv, changes, subst)
+        end
+
+        # Create base Hash type for Record
+        key_vtx = Source.new(genv.symbol_type)
+        # Create union of all field values for the Hash value type
+        val_vtx = changes.new_contravariant_vertex(genv, [self, :union])
+        field_vertices.each_value do |field_vtx|
+          changes.add_edge(genv, field_vtx, val_vtx)
+        end
+        base_hash_type = genv.gen_hash_type(key_vtx, val_vtx)
+
+        changes.add_edge(genv, Source.new(Type::Record.new(genv, field_vertices, base_hash_type)), vtx)
+      end
+
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, changes.target)
+        vtx.each_type do |ty|
+          case ty
+          when Type::Hash
+            @fields.each do |key, field_node|
+              val_vtx = ty.get_value(key)
+              return false unless field_node.typecheck(genv, changes, val_vtx, subst)
+            end
+            return true
+          end
+        end
+        false
       end
 
       def show
-        "(...record...)"
+        field_strs = @fields.map do |key, field_node|
+          "#{ key }: #{ field_node.show }"
+        end
+        "{ #{ field_strs.join(", ") } }"
       end
     end
 
@@ -516,6 +825,11 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(Type::Var.new(genv, @var, subst[@var])), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_edge(genv, vtx, subst[@var]) unless vtx == subst[@var]
+        true
+      end
+
       def show
         "#{ @var }"
       end
@@ -540,6 +854,10 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(genv.nil_type), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        @type.typecheck(genv, changes, vtx, subst)
+      end
+
       def show
         s = @type.show
         if @type.is_a?(SigTyIntersectionNode) || @type.is_a?(SigTyUnionNode)
@@ -579,22 +897,65 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(get_type(genv)), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        if @lit.is_a?(::Symbol)
+          changes.add_edge(genv, vtx, changes.target)
+          vtx.each_type do |ty|
+            case ty
+            when Type::Symbol
+              return true if ty.sym == @lit
+            end
+          end
+          return false
+        end
+        f_mod = get_type(genv).mod
+        AST.typecheck_for_module(genv, changes, f_mod, [], vtx, subst)
+      end
+
       def show
         @lit.inspect
       end
     end
 
     class SigTyProcNode < SigTyNode
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        # raw_decl.type is an RBS::Types::Function, we need to wrap it in a MethodType
+        if raw_decl.type
+          method_type = RBS::MethodType.new(
+            type: raw_decl.type,
+            type_params: [],
+            block: raw_decl.block,
+            location: raw_decl.location
+          )
+          @type = AST.create_rbs_func_type(method_type, nil, raw_decl.block, lenv)
+        else
+          @type = nil
+        end
+      end
+
+      attr_reader :type
+      def subnodes = { type: }
+
       def covariant_vertex0(genv, changes, vtx, subst)
-        raise NotImplementedError
+        # For now, just return the base Proc type without the function signature details
+        # TODO: Create a proper Type::Proc with the function signature
+        changes.add_edge(genv, Source.new(genv.proc_type), vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        Source.new()
+        # For now, just return the base Proc type without the function signature details
+        # TODO: Create a proper Type::Proc with the function signature
+        changes.add_edge(genv, Source.new(genv.proc_type), vtx)
+      end
+
+      def typecheck(genv, changes, vtx, subst)
+        # TODO: proper check
+        AST.typecheck_for_module(genv, changes, genv.proc_type.mod, [], vtx, subst)
       end
 
       def show
-        "(...proc...)"
+        "^(...)"
       end
     end
 
@@ -615,11 +976,11 @@ module TypeProf::Core
       def define0(genv)
         @args.each {|arg| arg.define(genv) }
         const_reads = []
-        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
         const_reads << const_read
         unless @cpath.empty?
           @cpath[1..].each do |cname|
-            const_read = ScopedConstRead.new(cname, const_read)
+            const_read = ScopedConstRead.new(cname, const_read, false)
             const_reads << const_read
           end
         end
@@ -651,6 +1012,15 @@ module TypeProf::Core
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
+      def typecheck(genv, changes, vtx, subst)
+        changes.add_depended_static_read(@static_ret.last)
+        cpath = @static_ret.last.cpath
+        return unless cpath
+        f_mod = genv.resolve_cpath(cpath)
+        # self/f_mod: formal, vtx: actual
+        AST.typecheck_for_module(genv, changes, f_mod, @args, vtx, subst)
+      end
+
       def show
         s = "::#{ @cpath.join("::") }"
         if !@args.empty?

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

@@ -272,7 +272,11 @@ module TypeProf::Core
             @vals << AST.create_node(raw_elem.value, lenv)
           when :assoc_splat_node
             @keys << nil
-            @vals << AST.create_node(raw_elem.value, lenv)
+            if raw_elem.value
+              @vals << AST.create_node(raw_elem.value, lenv)
+            else
+              @vals << DummyNilNode.new(code_range, lenv)
+            end
             @splat = true
           else
             raise "unknown hash elem: #{ raw_elem.type }"
@@ -297,7 +301,11 @@ module TypeProf::Core
             @changes.add_edge(genv, v, unified_val)
             literal_pairs[key.lit] = v if key.is_a?(SymbolNode)
           else
-            h = val.install(genv)
+            if val.is_a?(DummyNilNode)
+              h = @lenv.get_var(:"**anonymous_keyword")
+            else
+              h = val.install(genv)
+            end
             # TODO: do we want to call to_hash on h?
             @changes.add_hash_splat_box(genv, h, unified_key, unified_val)
           end