typeprof 0.31.0 → 0.32.0

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

@@ -6,7 +6,7 @@ module TypeProf::Core
         stmts = raw_node.body
         @stmts = stmts.map.with_index do |n, i|
           if n
-            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false)
+            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false, true)
           else
             last = code_range.last
             DummyNilNode.new(TypeProf::CodeRange.new(last, last), lenv)
@@ -139,6 +139,63 @@ module TypeProf::Core
       end
     end
 
+    class MultiTargetNode < Node
+      def initialize(raw_node, rhs, lenv)
+        super(raw_node, lenv)
+        @rhs = rhs
+        @lefts = raw_node.lefts.map do |raw_lhs|
+          AST.create_target_node(raw_lhs, lenv)
+        end
+        if raw_node.rest
+          case raw_node.rest.type
+          when :splat_node
+            if raw_node.rest.expression
+              @rest = AST.create_target_node(raw_node.rest.expression, lenv)
+            end
+          when :implicit_rest_node
+            # no assignment target
+          else
+            raise "unexpected rest node in multi_target: #{raw_node.rest.type}"
+          end
+        end
+        @rights = raw_node.rights.map do |raw_rhs|
+          AST.create_target_node(raw_rhs, lenv)
+        end
+      end
+
+      attr_reader :rhs, :lefts, :rest, :rights
+
+      def subnodes = { rhs:, lefts:, rest:, rights: }
+
+      def install0(genv)
+        # The rhs should be installed by the parent MultiWriteNode
+        # Here we set up the multi-assignment box for nested destructuring
+        value = @rhs.install(genv)
+
+        @lefts.each {|lhs| lhs.install(genv) }
+        @lefts.each {|lhs| lhs.rhs.ret || raise(lhs.rhs.inspect) }
+        lefts = @lefts.map {|lhs| lhs.rhs.ret }
+
+        rest_elem = nil
+        if @rest
+          rest_elem = Vertex.new(self)
+          @rest.install(genv)
+          @rest.rhs.ret || raise(@rest.rhs.inspect)
+          @changes.add_edge(genv, Source.new(Type::Instance.new(genv, genv.mod_ary, [rest_elem])), @rest.rhs.ret)
+        end
+
+        rights = nil
+        if @rights && !@rights.empty?
+          @rights.each {|rhs| rhs.install(genv) }
+          @rights.each {|rhs| rhs.rhs.ret || raise(rhs.rhs.inspect) }
+          rights = @rights.map {|rhs| rhs.rhs.ret }
+        end
+
+        box = @changes.add_masgn_box(genv, value, lefts, rest_elem, rights)
+        box.ret
+      end
+    end
+
     class MatchWriteNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
@@ -199,28 +256,48 @@ module TypeProf::Core
         vtx = @expr.install(genv)
 
         a_args = ActualArguments.new([], [], nil, nil)
-        vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false).ret
+        to_a_vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false, suppress_errors: true).ret
 
-        @changes.add_splat_box(genv, vtx).ret
+        @changes.add_splat_box(genv, to_a_vtx, nil, vtx).ret
       end
     end
 
     class ForNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        # XXX: tentative implementation
-        # raw_node.index
+        @index = AST.create_target_node(raw_node.index, lenv)
         @expr = AST.create_node(raw_node.collection, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
       end
 
-      attr_reader :expr, :body
+      attr_reader :index, :expr, :body
 
-      def subnodes = { expr:, body: }
+      def subnodes = { index:, expr:, body: }
 
       def install0(genv)
         @expr.install(genv)
+
+        vars = []
+        @index.modified_vars(@lenv.locals.keys, vars)
+        @body.modified_vars(@lenv.locals.keys, vars)
+        vars.uniq!
+
+        old_vtxs = {}
+        vars.each do |var|
+          vtx = @lenv.get_var(var)
+          nvtx = vtx.new_vertex(genv, self)
+          old_vtxs[var] = nvtx
+          @lenv.set_var(var, nvtx)
+        end
+
+        @index.install(genv)
         @body.install(genv)
+
+        vars.each do |var|
+          @changes.add_edge(genv, @lenv.get_var(var), old_vtxs[var])
+          @lenv.set_var(var, old_vtxs[var])
+        end
+
         Source.new(genv.nil_type)
       end
     end

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

@@ -12,13 +12,13 @@ module TypeProf::Core
 
         if @static_cpath
           ncref = CRef.new(@static_cpath, meta ? :metaclass : :class, nil, lenv.cref)
-          nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+          nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
           @body = raw_scope ? AST.create_node(raw_scope, nlenv, use_result) : DummyNilNode.new(code_range, lenv)
         else
           @body = nil
         end
 
-        @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+        @cname_code_range = meta ? nil : lenv.code_range_from_node(raw_node.constant_path)
         @mod_cdef = nil
       end
 
@@ -89,7 +89,22 @@ module TypeProf::Core
       def initialize(raw_node, lenv, use_result)
         super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
         raw_superclass = raw_node.superclass
-        @superclass_cpath = raw_superclass ? AST.create_node(raw_superclass, lenv) : nil
+        if raw_superclass
+          # In Ruby, the superclass expression is evaluated before the class constant
+          # is created. When the superclass is a bare constant with the same name as
+          # the class being defined (e.g., `class Foo < Foo` inside a module), use the
+          # outer scope to avoid resolving to the class itself.
+          if @static_cpath && lenv.cref.outer &&
+             raw_superclass.type == :constant_read_node &&
+             raw_superclass.name == @static_cpath.last
+            slenv = LocalEnv.new(lenv.file_context, lenv.cref.outer, {}, [])
+            @superclass_cpath = AST.create_node(raw_superclass, slenv)
+          else
+            @superclass_cpath = AST.create_node(raw_superclass, lenv)
+          end
+        else
+          @superclass_cpath = nil
+        end
       end
 
       attr_reader :superclass_cpath
@@ -113,6 +128,21 @@ module TypeProf::Core
 
       def install0(genv)
         @superclass_cpath.install(genv) if @superclass_cpath
+        if @static_cpath && @superclass_cpath
+          const_read = @superclass_cpath.static_ret
+          if const_read && const_read.cpath
+            super_mod = genv.resolve_cpath(const_read.cpath)
+            self_mod = genv.resolve_cpath(@static_cpath)
+            mod = super_mod
+            while mod
+              if mod == self_mod
+                @changes.add_diagnostic(:code_range, "circular inheritance", @superclass_cpath)
+                break
+              end
+              mod = mod.superclass
+            end
+          end
+        end
         super(genv)
       end
     end

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

@@ -15,20 +15,27 @@ module TypeProf::Core
         # TODO: decl.type_params
         # TODO: decl.super_class.args
         ncref = CRef.new(@cpath, :class, nil, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
         @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
+        end
       end
 
-      attr_reader :cpath, :members, :params
+      attr_reader :cpath, :members, :params, :params_default_types
 
-      def subnodes = { members: }
+      def subnodes = { members:, params_default_types: }
       def attrs = { cpath:, params: }
 
       def define0(genv)
+        @params_default_types.each do |ty|
+          ty&.define(genv)
+        end
         @members.each do |member|
           member.define(genv)
         end
@@ -46,6 +53,9 @@ module TypeProf::Core
       def undefine0(genv)
         mod = genv.resolve_cpath(@cpath)
         mod.remove_module_decl(genv, self)
+        @params_default_types.each do |ty|
+          ty&.undefine(genv)
+        end
         @members.each do |member|
           member.undefine(genv)
         end
@@ -180,19 +190,19 @@ module TypeProf::Core
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
         @mid = raw_decl.name
-        @mid_code_range = TypeProf::CodeRange.from_node(raw_decl.location[:name])
+        @mid_code_range = lenv.code_range_from_node(raw_decl.location[:name])
         @singleton = raw_decl.singleton?
         @instance = raw_decl.instance?
-        @method_types = raw_decl.overloads.map do |overload|
+        @method_types = OverloadSet.new(raw_decl.overloads.map do |overload|
           method_type = overload.method_type
           AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
-        end
+        end)
         @overloading = raw_decl.overloading
       end
 
       attr_reader :mid, :singleton, :instance, :method_types, :overloading, :mid_code_range
 
-      def subnodes = { method_types: }
+      def subnodes = { method_types: @method_types.to_a }
       def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
 
       def mname_code_range(_name) = @mid_code_range
@@ -222,10 +232,10 @@ 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, false)
+        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, false)
+          const_read = ScopedConstRead.new(cname, const_read, true)
           const_reads << const_read
         end
         mod = genv.resolve_cpath(@lenv.cref.cpath)
@@ -271,10 +281,10 @@ 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, false)
+        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, false)
+          const_read = ScopedConstRead.new(cname, const_read, true)
           const_reads << const_read
         end
         mod = genv.resolve_cpath(@lenv.cref.cpath)
@@ -336,6 +346,7 @@ module TypeProf::Core
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -344,7 +355,7 @@ module TypeProf::Core
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
@@ -371,6 +382,7 @@ module TypeProf::Core
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -379,7 +391,7 @@ module TypeProf::Core
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
@@ -402,6 +414,52 @@ module TypeProf::Core
       end
     end
 
+    class SigModuleAliasBaseNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        @cpath = AST.resolve_rbs_name(raw_decl.new_name, lenv)
+        @old_cpath = AST.resolve_rbs_name(raw_decl.old_name, lenv)
+      end
+
+      attr_reader :cpath, :old_cpath
+      def attrs = { cpath:, old_cpath: }
+
+      def define0(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        cname = @cpath.last
+        alias_mod = outer.inner_modules[cname] ||= ModuleEntity.new(outer.cpath + [cname], outer)
+        target_mod = genv.resolve_cpath(@old_cpath)
+        alias_mod.add_alias_decl(genv, self, target_mod)
+      end
+
+      def define_copy(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        alias_mod = outer.inner_modules[@cpath.last]
+        target_mod = genv.resolve_cpath(@old_cpath)
+        alias_mod.add_alias_decl(genv, self, target_mod)
+        alias_mod.remove_alias_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        alias_mod = outer.inner_modules[@cpath.last]
+        alias_mod.remove_alias_decl(genv, self)
+      end
+
+      def install0(genv)
+        mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@cpath)))
+        @changes.add_edge(genv, mod_val, @static_ret.vtx)
+        Source.new
+      end
+    end
+
+    class SigClassAliasNode < SigModuleAliasBaseNode
+    end
+
+    class SigModuleAliasNode < SigModuleAliasBaseNode
+    end
+
     class SigConstNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
@@ -415,9 +473,10 @@ module TypeProf::Core
 
       def define0(genv)
         @type.define(genv)
-        mod = genv.resolve_const(@cpath)
-        mod.add_decl(self)
-        mod
+        cdef = genv.resolve_const(@cpath)
+        cdef.on_const_added(genv, @cpath)
+        cdef.add_decl(self)
+        cdef
       end
 
       def define_copy(genv)
@@ -428,7 +487,9 @@ module TypeProf::Core
       end
 
       def undefine0(genv)
-        genv.resolve_const(@cpath).remove_decl(self)
+        cdef = genv.resolve_const(@cpath)
+        cdef.remove_decl(self)
+        cdef.on_const_removed(genv, @cpath)
         @type.undefine(genv)
       end
 
@@ -490,20 +551,20 @@ module TypeProf::Core
 
       def define0(genv)
         @type.define(genv)
-        mod = genv.resolve_ivar(cpath, @class_scope, @var)
-        mod.add_decl(self)
-        mod
+        mod = genv.resolve_cpath(cpath)
+        mod.add_ivar_decl(genv, @class_scope, @var, self)
       end
 
       def define_copy(genv)
-        mod = genv.resolve_ivar(cpath, @class_scope, @var)
-        mod.add_decl(self)
-        mod.remove_decl(@prev_node)
+        mod = genv.resolve_cpath(cpath)
+        mod.add_ivar_decl(genv, @class_scope, @var, self)
+        mod.remove_ivar_decl(genv, @class_scope, @var, @prev_node)
         super(genv)
       end
 
       def undefine0(genv)
-        genv.resolve_ivar(cpath, @class_scope, @var).remove_decl(self)
+        mod = genv.resolve_cpath(cpath)
+        mod.remove_ivar_decl(genv, @class_scope, @var, self)
         @type.undefine(genv)
       end