typeprof 0.30.1 → 0.31.0

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

@@ -19,6 +19,7 @@ module TypeProf::Core
         end
 
         @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+        @mod_cdef = nil
       end
 
       attr_reader :tbl, :cpath, :static_cpath, :cname_code_range, :body
@@ -29,9 +30,9 @@ module TypeProf::Core
       def define0(genv)
         @cpath.define(genv)
         if @static_cpath
+          mod = genv.resolve_cpath(@static_cpath)
+          @mod_cdef = mod.add_module_def(genv, self)
           @body.define(genv)
-          @mod = genv.resolve_cpath(@static_cpath)
-          @mod_cdef = @mod.add_module_def(genv, self)
         else
           kind = self.is_a?(ModuleNode) ? "module" : "class"
           @changes.add_diagnostic(:code_range, "TypeProf cannot analyze a non-static #{ kind }") # warning
@@ -41,15 +42,17 @@ module TypeProf::Core
 
       def define_copy(genv)
         if @static_cpath
-          @mod_cdef.add_def(self)
-          @mod_cdef.remove_def(@prev_node)
+          mod = genv.resolve_cpath(@static_cpath)
+          @mod_cdef = mod.add_module_def(genv, self)
+          mod.remove_module_def(genv, @prev_node)
         end
         super(genv)
       end
 
       def undefine0(genv)
         if @static_cpath
-          @mod.remove_module_def(genv, self)
+          mod = genv.resolve_cpath(@static_cpath)
+          mod.remove_module_def(genv, self)
           @body.undefine(genv)
         end
         @cpath.undefine(genv)
@@ -61,8 +64,8 @@ module TypeProf::Core
           @tbl.each {|var| @body.lenv.locals[var] = Source.new(genv.nil_type) }
           @body.lenv.locals[:"*self"] = @body.lenv.cref.get_self(genv)
 
-          @mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
-          @changes.add_edge(genv, @mod_val, @mod_cdef.vtx)
+          mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
+          @changes.add_edge(genv, mod_val, @mod_cdef.vtx)
           ret = Vertex.new(self)
           @changes.add_edge(genv, @body.install(genv), ret)
           ret

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

@@ -5,7 +5,15 @@ module TypeProf::Core
         super(raw_node, lenv)
         @requireds = raw_node.requireds.map {|raw_pat| AST.create_pattern_node(raw_pat, lenv) }
         @rest = !!raw_node.rest
-        @rest_pattern = raw_node.rest && raw_node.rest.expression ? AST.create_pattern_node(raw_node.rest.expression, lenv) : nil
+        @rest_pattern = case raw_node.rest
+                        when Prism::SplatNode
+                          AST.create_pattern_node(raw_node.rest.expression, lenv) if raw_node.rest.expression
+                        when Prism::ImplicitRestNode, nil
+                          nil
+                        else
+                          raise
+                        end
+
         @posts = raw_node.posts.map {|raw_pat| AST.create_pattern_node(raw_pat, lenv) }
       end
 

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

@@ -52,8 +52,8 @@ module TypeProf::Core
       end
 
       def install0(genv)
-        @mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@cpath)))
-        @changes.add_edge(genv, @mod_val, @static_ret[:module].vtx)
+        mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@cpath)))
+        @changes.add_edge(genv, mod_val, @static_ret[:module].vtx)
         @members.each do |member|
           member.install(genv)
         end
@@ -89,10 +89,10 @@ module TypeProf::Core
         static_ret[:self_types] = self_types = []
         @self_types.zip(@self_type_args) do |(cpath, toplevel), args|
           args.each {|arg| arg.define(genv) }
-          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]
           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
           mod = genv.resolve_cpath(@cpath)
@@ -150,10 +150,10 @@ module TypeProf::Core
         const_reads = []
         if @superclass_cpath
           @superclass_args.each {|arg| arg.define(genv) }
-          const_read = BaseConstRead.new(genv, @superclass_cpath.first, @superclass_toplevel ? CRef::Toplevel : @lenv.cref)
+          const_read = BaseConstRead.new(genv, @superclass_cpath.first, @superclass_toplevel ? CRef::Toplevel : @lenv.cref, false)
           const_reads << const_read
           @superclass_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
           mod = genv.resolve_cpath(@cpath)
@@ -180,6 +180,7 @@ 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])
         @singleton = raw_decl.singleton?
         @instance = raw_decl.instance?
         @method_types = raw_decl.overloads.map do |overload|
@@ -189,10 +190,12 @@ module TypeProf::Core
         @overloading = raw_decl.overloading
       end
 
-      attr_reader :mid, :singleton, :instance, :method_types, :overloading
+      attr_reader :mid, :singleton, :instance, :method_types, :overloading, :mid_code_range
 
       def subnodes = { method_types: }
-      def attrs = { mid:, singleton:, instance:, overloading: }
+      def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
+
+      def mname_code_range(_name) = @mid_code_range
 
       def install0(genv)
         [[@singleton, true], [@instance, false]].each do |enabled, singleton|
@@ -219,10 +222,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)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
         const_reads << const_read
         @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
         mod = genv.resolve_cpath(@lenv.cref.cpath)
@@ -252,6 +255,55 @@ module TypeProf::Core
       end
     end
 
+    class SigPrependNode < 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, false)
+        const_reads << const_read
+        @cpath[1..].each do |cname|
+          const_read = ScopedConstRead.new(cname, const_read, false)
+          const_reads << const_read
+        end
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        const_read.followers << mod
+        mod.add_prepend_decl(genv, self)
+        const_reads
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.add_prepend_decl(genv, self)
+        mod.remove_prepend_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.remove_prepend_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)
@@ -277,17 +329,13 @@ module TypeProf::Core
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
         @mid = raw_decl.name
-        # `eval` is used to prevent TypeProf from failing to parse keyword arguments during dogfooding.
-        # TODO: Remove `eval` once TypeProf supports keyword arguments.
-        eval <<~RUBY
-          rbs_method_type = RBS::MethodType.new(
-            type: RBS::Types::Function.empty(raw_decl.type),
-            type_params: [],
-            block: nil,
-            location: raw_decl.type.location,
-          )
-          @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
-        RUBY
+        rbs_method_type = RBS::MethodType.new(
+          type: RBS::Types::Function.empty(raw_decl.type),
+          type_params: [],
+          block: nil,
+          location: raw_decl.type.location
+        )
+        @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
       end
 
       attr_reader :mid, :method_type
@@ -306,27 +354,23 @@ module TypeProf::Core
         super(raw_decl, lenv)
         @mid = :"#{raw_decl.name}="
 
-        # `eval` is used to prevent TypeProf from failing to parse keyword arguments during dogfooding.
-        # TODO: Remove `eval` once TypeProf supports keyword arguments.
-        eval <<~RUBY
-          # (raw_decl.type) -> raw_decl.type
-          rbs_method_type = RBS::MethodType.new(
-            type: RBS::Types::Function.new(
-              required_positionals: [RBS::Types::Function::Param.new(name: nil, type: raw_decl.type, location: raw_decl.type.location)],
-              optional_positionals: [],
-              rest_positionals: nil,
-              trailing_positionals: [],
-              required_keywords: {},
-              optional_keywords: {},
-              rest_keywords: nil,
-              return_type: raw_decl.type,
-            ),
-            type_params: [],
-            block: nil,
-            location: raw_decl.type.location,
-          )
-          @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
-        RUBY
+        # (raw_decl.type) -> raw_decl.type
+        rbs_method_type = RBS::MethodType.new(
+          type: RBS::Types::Function.new(
+            required_positionals: [RBS::Types::Function::Param.new(name: nil, type: raw_decl.type, location: raw_decl.type.location)],
+            optional_positionals: [],
+            rest_positionals: nil,
+            trailing_positionals: [],
+            required_keywords: {},
+            optional_keywords: {},
+            rest_keywords: nil,
+            return_type: raw_decl.type
+          ),
+          type_params: [],
+          block: nil,
+          location: raw_decl.type.location
+        )
+        @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
       end
 
       attr_reader :mid, :method_type
@@ -431,6 +475,83 @@ module TypeProf::Core
       end
     end
 
+    class SigInstanceVariableNode < Node
+      def initialize(raw_decl, lenv, class_scope)
+        super(raw_decl, lenv)
+        @var = raw_decl.name
+        @cpath = lenv.cref.cpath
+        @class_scope = class_scope
+        @type = AST.create_rbs_type(raw_decl.type, lenv)
+      end
+
+      attr_reader :cpath, :class_scope, :type
+      def subnodes = { type: }
+      def attrs = { cpath:, class_scope: }
+
+      def define0(genv)
+        @type.define(genv)
+        mod = genv.resolve_ivar(cpath, @class_scope, @var)
+        mod.add_decl(self)
+        mod
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_ivar(cpath, @class_scope, @var)
+        mod.add_decl(self)
+        mod.remove_decl(@prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        genv.resolve_ivar(cpath, @class_scope, @var).remove_decl(self)
+        @type.undefine(genv)
+      end
+
+      def install0(genv)
+        box = @changes.add_type_read_box(genv, @type)
+        @changes.add_edge(genv, box.ret, @static_ret.vtx)
+        box.ret
+      end
+    end
+
+    class SigClassVariableNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        @var = raw_decl.name
+        @cpath = lenv.cref.cpath
+        @type = AST.create_rbs_type(raw_decl.type, lenv)
+      end
+
+      attr_reader :cpath, :type
+      def subnodes = { type: }
+      def attrs = { cpath: }
+
+      def define0(genv)
+        @type.define(genv)
+        cvar = genv.resolve_cvar(cpath, @var)
+        cvar.add_decl(self)
+        cvar
+      end
+
+      def define_copy(genv)
+        cvar = genv.resolve_cvar(cpath, @var)
+        cvar.add_decl(self)
+        cvar.remove_decl(@prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        genv.resolve_cvar(cpath, @var).remove_decl(self)
+        @type.undefine(genv)
+      end
+
+      def install0(genv)
+        box = @changes.add_type_read_box(genv, @type)
+        @changes.add_edge(genv, box.ret, @static_ret.vtx)
+        box.ret
+      end
+    end
+
     class SigGlobalVariableNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)