typeprof 0.31.1 → 0.33.0

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

@@ -8,7 +8,7 @@ module TypeProf::Core
           @cbase = nil
           @toplevel = false
           @cname = raw_node.name
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.location)
+          @cname_code_range_loc = raw_node.location
         when :constant_path_node, :constant_path_target_node
           if raw_node.parent
             @cbase = AST.create_node(raw_node.parent, lenv)
@@ -18,14 +18,18 @@ module TypeProf::Core
             @toplevel = true
           end
           @cname = raw_node.name
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+          @cname_code_range_loc = raw_node.name_loc
         else
           raise raw_node.type.to_s
         end
         @strict_const_scope = lenv.strict_const_scope
       end
 
-      attr_reader :cname, :cbase, :toplevel, :cname_code_range, :strict_const_scope
+      attr_reader :cname, :cbase, :toplevel, :strict_const_scope
+
+      def cname_code_range
+        @cname_code_range ||= @lenv.code_range_from_node(@cname_code_range_loc) if @cname_code_range_loc
+      end
 
       def attrs = { cname:, toplevel:, strict_const_scope: }
       def subnodes = { cbase: }
@@ -57,24 +61,28 @@ module TypeProf::Core
           # C = expr
           @cpath = nil
           @static_cpath = lenv.cref.cpath + [raw_node.name]
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+          @cname_code_range_loc = raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node.location
         when :constant_path_write_node, :constant_path_operator_write_node, :constant_path_or_write_node, :constant_path_and_write_node
           # expr::C = expr
           @cpath = AST.create_node(raw_node.target, lenv)
           @static_cpath = AST.parse_cpath(raw_node.target, lenv.cref)
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.target)
+          @cname_code_range_loc = raw_node.target.location
         when :constant_path_target_node
           # expr::C, * = ary
           @cpath = ConstantReadNode.new(raw_node, lenv)
           @static_cpath = AST.parse_cpath(raw_node, lenv.cref)
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node)
+          @cname_code_range_loc = raw_node.location
         else
           raise
         end
         @rhs = rhs
       end
 
-      attr_reader :cpath, :rhs, :static_cpath, :cname_code_range
+      attr_reader :cpath, :rhs, :static_cpath
+
+      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:, rhs: }
       def attrs = { static_cpath: }
@@ -83,9 +91,10 @@ module TypeProf::Core
         @cpath.define(genv) if @cpath
         @rhs.define(genv) if @rhs
         if @static_cpath
-          mod = genv.resolve_const(@static_cpath)
-          mod.add_def(self)
-          mod
+          cdef = genv.resolve_const(@static_cpath)
+          cdef.on_const_added(genv, @static_cpath)
+          cdef.add_def(self)
+          cdef
         else
           nil
         end
@@ -102,7 +111,9 @@ module TypeProf::Core
 
       def undefine0(genv)
         if @static_cpath
-          genv.resolve_const(@static_cpath).remove_def(self)
+          cdef = genv.resolve_const(@static_cpath)
+          cdef.remove_def(self)
+          cdef.on_const_removed(genv, @static_cpath)
         end
         @rhs.undefine(genv) if @rhs
         @cpath.undefine(genv) if @cpath

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

@@ -203,7 +203,7 @@ module TypeProf::Core
 
       def install0(genv)
         arg = @arg.install(genv)
-        @changes.add_edge(genv, arg, @lenv.get_break_vtx)
+        @changes.add_edge(genv, arg.new_vertex(genv, self), @lenv.get_break_vtx)
         Source.new()
       end
     end
@@ -236,7 +236,7 @@ module TypeProf::Core
         if @lenv.exist_var?(:"*expected_block_ret")
           @lenv.add_next_box(@changes.add_escape_box(genv, @arg.ret))
         end
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 
@@ -322,44 +322,74 @@ module TypeProf::Core
         ret = Vertex.new(self)
         @pivot&.install(genv)
 
-        # case文での型絞り込みを実装
-        if @pivot && @pivot.is_a?(LocalVariableReadNode)
-          var = @pivot.var
-          original_vtx = @lenv.get_var(var)
+        # Collect modified variables across all branches
+        vars = []
+        @when_nodes.each {|wn| wn.body.modified_vars(@lenv.locals.keys, vars) }
+        @else_clause.modified_vars(@lenv.locals.keys, vars) if @else_clause
+        vars.uniq!
 
-          # ダミー変数に元の型情報を設定
-          @lenv.set_var(:"*pivot", original_vtx)
+        # Save original variable vertices
+        saved_vtxs = {}
+        vars.each do |var|
+          saved_vtxs[var] = @lenv.get_var(var)
+        end
 
-          # 各when節を実行
-          @when_nodes.each do |when_node|
-            clause_result = when_node.install(genv)
-            @changes.add_edge(genv, clause_result, ret)
-            # 元の型に戻す
-            @lenv.set_var(var, original_vtx)
-          end
+        # Prepare per-branch result vertices
+        branch_vtxs = []
 
-          # else節（他のwhen節で除外された後の型）
-          filtered_else_vtx = original_vtx.new_vertex(genv, self)
+        # Setup pivot narrowing if applicable
+        pivot_var = @pivot.is_a?(LocalVariableReadNode) ? @pivot.var : nil
+        if pivot_var
+          original_pivot = @lenv.get_var(pivot_var)
+          @lenv.set_var(:"*pivot", original_pivot)
+        end
+
+        # Install each when branch
+        @when_nodes.each do |when_node|
+          # Reset variables to original for each branch
+          saved_vtxs.each {|var, vtx| @lenv.set_var(var, vtx.new_vertex(genv, self)) }
+          @lenv.set_var(pivot_var, original_pivot) if pivot_var
+
+          clause_val = when_node.install(genv)
+          @changes.add_edge(genv, clause_val, ret)
+
+          modified = {}
+          vars.each {|var| modified[var] = @lenv.get_var(var) }
+          branch_vtxs << [clause_val, modified]
+        end
+
+        # Install else branch
+        saved_vtxs.each {|var, vtx| @lenv.set_var(var, vtx.new_vertex(genv, self)) }
+        if pivot_var
+          # Apply exclusion filters for else
+          filtered_else_vtx = original_pivot.new_vertex(genv, self)
           @when_nodes.each do |when_node|
             when_node.get_exclusion_conditions.each do |static_ret|
-              # 各when節の型を除外（negation）
               filtered_else_vtx = IsAFilter.new(genv, self, filtered_else_vtx, true, static_ret).next_vtx
             end
           end
-          @lenv.set_var(var, filtered_else_vtx)
-          @changes.add_edge(genv, @else_clause.install(genv), ret)
-          @lenv.set_var(var, original_vtx)
+          @lenv.set_var(pivot_var, filtered_else_vtx)
+        end
+        else_val = @else_clause.install(genv)
+        @changes.add_edge(genv, else_val, ret)
 
-          # ダミー変数をクリア
-          @lenv.locals.delete(:"*pivot")
-        else
-          # pivotが変数でない場合は従来通り
-          @when_nodes.each do |when_node|
-            @changes.add_edge(genv, when_node.install(genv), ret)
+        else_modified = {}
+        vars.each {|var| else_modified[var] = @lenv.get_var(var) }
+        branch_vtxs << [else_val, else_modified]
+
+        # Join all branches
+        vars.each do |var|
+          joined = Vertex.new(self)
+          branch_vtxs.each do |branch_val, modified|
+            vtx = BotFilter.new(genv, self, modified[var], branch_val).next_vtx
+            @changes.add_edge(genv, vtx, joined)
           end
-          @changes.add_edge(genv, @else_clause.install(genv), ret)
+          @lenv.set_var(var, joined)
         end
 
+        # Cleanup
+        @lenv.locals.delete(:"*pivot") if pivot_var
+
         ret
       end
     end
@@ -384,9 +414,9 @@ module TypeProf::Core
 
       def install0(genv)
         ret = Vertex.new(self)
-        @pivot&.install(genv)
+        subject = @pivot ? @pivot.install(genv) : Source.new(genv.nil_type)
         @patterns.zip(@clauses) do |pattern, clause|
-          pattern.install(genv)
+          pattern.install_pattern(genv, subject)
           @changes.add_edge(genv, clause.install(genv), ret)
         end
         @changes.add_edge(genv, @else_clause.install(genv), ret) if @else_clause
@@ -496,7 +526,7 @@ module TypeProf::Core
         @arg.install(genv)
         e_ret = @lenv.locals[:"*expected_method_ret"]
         @lenv.add_return_box(@changes.add_escape_box(genv, @arg.ret)) if e_ret
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 
@@ -681,7 +711,7 @@ module TypeProf::Core
       end
 
       def install0(genv)
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 

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

@@ -46,9 +46,56 @@ module TypeProf::Core
       end
     end
 
+    class ExtendMetaNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        # TODO: error for splat
+        @args = raw_node.arguments.arguments.map do |raw_arg|
+          next if raw_arg.is_a?(Prism::SplatNode)
+          lenv.use_strict_const_scope do
+            AST.create_node(raw_arg, lenv)
+          end
+        end.compact
+        # TODO: error for non-LIT
+        # TODO: fine-grained hover
+      end
+
+      attr_reader :args
+
+      def subnodes = { args: }
+
+      def define0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        @args.each do |arg|
+          arg.define(genv)
+          if arg.static_ret
+            arg.static_ret.followers << mod
+            mod.add_extend_def(genv, arg)
+          end
+        end
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        @args.each do |arg|
+          if arg.static_ret
+            mod.remove_extend_def(genv, arg)
+          end
+          arg.undefine(genv)
+        end
+        super(genv)
+      end
+
+      def install0(genv)
+        @args.each {|arg| arg.install(genv) }
+        Source.new
+      end
+    end
+
     class AttrReaderMetaNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
+        @singleton = lenv.cref.scope_level == :metaclass
         @args = []
         raw_node.arguments.arguments.each do |raw_arg|
           @args << raw_arg.value.to_sym if raw_arg.type == :symbol_node
@@ -57,9 +104,9 @@ module TypeProf::Core
         # TODO: fine-grained hover
       end
 
-      attr_reader :args
+      attr_reader :singleton, :args
 
-      def attrs = { args: }
+      def attrs = { singleton:, args: }
 
       def req_positionals = []
       def opt_positionals = []
@@ -68,19 +115,83 @@ module TypeProf::Core
       def req_keywords = []
       def opt_keywords = []
       def rest_keywords = nil
+      def no_keywords = false
 
       def mname_code_range(name)
         idx = @args.index(name.to_sym) # TODO: support string args
         node = @raw_node.arguments.arguments[idx].location
-        TypeProf::CodeRange.from_node(node)
+        @lenv.code_range_from_node(node)
       end
 
       def install0(genv)
         @args.each do |arg|
           ivar_name = :"@#{ arg }"
-          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, ivar_name)
+          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, @singleton, ivar_name)
           ret_box = @changes.add_escape_box(genv, ivar_box.ret)
-          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, arg, FormalArguments::Empty, [ret_box])
+        end
+        Source.new
+      end
+    end
+
+    class AttrWriterMetaNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @singleton = lenv.cref.scope_level == :metaclass
+        @args = []
+        raw_node.arguments.arguments.each do |raw_arg|
+          @args << raw_arg.value.to_sym if raw_arg.type == :symbol_node
+        end
+      end
+
+      attr_reader :singleton, :args
+
+      def attrs = { singleton:, args: }
+
+      # Interface expected by MethodDefBox
+      def req_keywords = []
+      def opt_keywords = []
+      def rest_keywords = nil
+      def no_keywords = false
+
+      def mname_code_range(name)
+        idx = @args.index(name.to_sym)
+        node = @raw_node.arguments.arguments[idx].location
+        @lenv.code_range_from_node(node)
+      end
+
+      def define0(genv)
+        @args.map do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
+          mod.add_def(self)
+          mod
+        end
+      end
+
+      def define_copy(genv)
+        @args.map do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
+          mod.add_def(self)
+          mod.remove_def(@prev_node)
+          mod
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        @args.each do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
+          mod.remove_def(self)
+        end
+      end
+
+      def install0(genv)
+        @args.zip(@static_ret) do |arg, ive|
+          vtx = Vertex.new(self)
+          @changes.add_edge(genv, vtx, ive.vtx)
+          ret_box = @changes.add_escape_box(genv, vtx)
+          f_args = FormalArguments.new([vtx], [], nil, [], [], [], nil, nil)
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, :"#{ arg }=", f_args, [ret_box])
         end
         Source.new
       end
@@ -89,6 +200,7 @@ module TypeProf::Core
     class AttrAccessorMetaNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
+        @singleton = lenv.cref.scope_level == :metaclass
         @args = []
         raw_node.arguments.arguments.each do |raw_arg|
           @args << raw_arg.value.to_sym if raw_arg.type == :symbol_node
@@ -97,19 +209,25 @@ module TypeProf::Core
         # TODO: fine-grained hover
       end
 
-      attr_reader :args
+      attr_reader :singleton, :args
 
-      def attrs = { args: }
+      def attrs = { singleton:, args: }
+
+      # Interface expected by MethodDefBox
+      def req_keywords = []
+      def opt_keywords = []
+      def rest_keywords = nil
+      def no_keywords = false
 
       def mname_code_range(name)
         idx = @args.index(name.to_sym) # TODO: support string args
         node = @raw_node.arguments.arguments[idx].location
-        TypeProf::CodeRange.from_node(node)
+        @lenv.code_range_from_node(node)
       end
 
       def define0(genv)
         @args.map do |arg|
-          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
           mod.add_def(self)
           mod
         end
@@ -117,7 +235,7 @@ module TypeProf::Core
 
       def define_copy(genv)
         @args.map do |arg|
-          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
           mod.add_def(self)
           mod.remove_def(@prev_node)
           mod
@@ -127,24 +245,171 @@ module TypeProf::Core
 
       def undefine0(genv)
         @args.each do |arg|
-          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod = genv.resolve_ivar(lenv.cref.cpath, @singleton, :"@#{ arg }")
           mod.remove_def(self)
         end
       end
 
       def install0(genv)
         @args.zip(@static_ret) do |arg, ive|
-          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, :"@#{ arg }")
+          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, @singleton, :"@#{ arg }")
           ret_box = @changes.add_escape_box(genv, ivar_box.ret)
-          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, arg, FormalArguments::Empty, [ret_box])
 
           vtx = Vertex.new(self)
           @changes.add_edge(genv, vtx, ive.vtx)
           f_args = FormalArguments.new([vtx], [], nil, [], [], [], nil, nil)
-          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, :"#{ arg }=", f_args, [ret_box])
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, :"#{ arg }=", f_args, [ret_box])
         end
         Source.new
       end
     end
+    class ModuleFunctionMetaNode < Node
+      def install0(genv)
+        @lenv.module_function = true
+        Source.new
+      end
+    end
+
+    class StructNewNode < Node
+      def initialize(raw_node, members, kind, lenv)
+        super(raw_node, lenv)
+        case raw_node.type
+        when :constant_write_node
+          @static_cpath = lenv.cref.cpath + [raw_node.name]
+        when :constant_path_write_node
+          @static_cpath = AST.parse_cpath(raw_node.target, lenv.cref)
+        else
+          raise
+        end
+        @members = members
+        @kind = kind # :struct or :data
+
+        # Parse block body if present (Struct.new(:foo) do ... end)
+        raw_value = raw_node.value
+        if raw_value.block && raw_value.block.type == :block_node && raw_value.block.body
+          ncref = CRef.new(@static_cpath, :instance, nil, lenv.cref)
+          nlenv = LocalEnv.new(lenv.file_context, ncref, {}, [])
+          @block_body = AST.create_node(raw_value.block.body, nlenv)
+        end
+      end
+
+      attr_reader :static_cpath, :members, :kind, :block_body
+
+      # Not a valid constant name, so no Ruby code can refer to it
+      BASE_CNAME = :"<struct base>"
+
+      def struct_base_cpath = @static_cpath + [BASE_CNAME]
+
+      def subnodes = { block_body: }
+      def attrs = { static_cpath:, members:, kind: }
+
+      # Interface expected by MethodDefBox
+      def req_positionals = @kind == :struct ? @members : []
+      def opt_positionals = []
+      def rest_positionals = nil
+      def post_positionals = []
+      def req_keywords = @kind == :data ? @members : []
+      def opt_keywords = []
+      def rest_keywords = nil
+      def no_keywords = @kind == :struct
+
+      def define0(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        # add_module_def internally calls get_const(name).add_def(self)
+        cdef = mod.add_module_def(genv, self)
+        genv.resolve_cpath(struct_base_cpath).add_module_def(genv, self)
+        @members.each do |member|
+          ive = genv.resolve_ivar(struct_base_cpath, false, member)
+          ive.add_def(self)
+        end
+        @block_body.define(genv) if @block_body
+        cdef
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        mod.add_module_def(genv, self)
+        mod.remove_module_def(genv, @prev_node)
+        base = genv.resolve_cpath(struct_base_cpath)
+        base.add_module_def(genv, self)
+        base.remove_module_def(genv, @prev_node)
+        @members.each do |member|
+          ive = genv.resolve_ivar(struct_base_cpath, false, member)
+          ive.add_def(self)
+          ive.remove_def(@prev_node)
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        mod.remove_module_def(genv, self)
+        genv.resolve_cpath(struct_base_cpath).remove_module_def(genv, self)
+        @members.each do |member|
+          ive = genv.resolve_ivar(struct_base_cpath, false, member)
+          ive.remove_def(self)
+        end
+        @block_body.undefine(genv) if @block_body
+      end
+
+      def install0(genv)
+        # Register the class singleton type as the constant value
+        mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
+        if @static_cpath
+          @changes.add_edge(genv, mod_val, @static_ret.vtx)
+        end
+
+        cpath = struct_base_cpath
+        @members.each do |member|
+          # Use bare `:member` (not `:@member`) so the slot can't collide with a
+          # user-written @member ivar — Struct/Data fields are not real ivars.
+          ivar_box = @changes.add_ivar_read_box(genv, cpath, false, member)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret)
+          @changes.add_method_def_box(genv, cpath, false, member, FormalArguments::Empty, [ret_box])
+
+          if @kind == :struct
+            # attr_writer (Struct only, Data is frozen)
+            ive = genv.resolve_ivar(cpath, false, member)
+            vtx = Vertex.new(self)
+            @changes.add_edge(genv, vtx, ive.vtx)
+            writer_ret = @changes.add_escape_box(genv, vtx)
+            f_args = FormalArguments.new([vtx], [], nil, [], [], [], nil, nil)
+            @changes.add_method_def_box(genv, cpath, false, :"#{ member }=", f_args, [writer_ret])
+          end
+        end
+
+        # initialize
+        init_vtxs = @members.map do |member|
+          ive = genv.resolve_ivar(cpath, false, member)
+          vtx = Vertex.new(self)
+          @changes.add_edge(genv, vtx, ive.vtx)
+          vtx
+        end
+        init_ret = @changes.add_escape_box(genv, Source.new(genv.nil_type))
+        if @kind == :struct
+          init_f_args = FormalArguments.new(init_vtxs, [], nil, [], [], [], nil, nil)
+        else
+          # Data.define uses keyword arguments
+          init_f_args = FormalArguments.new([], [], nil, [], init_vtxs, [], nil, nil)
+        end
+        @changes.add_method_def_box(genv, cpath, false, :initialize, init_f_args, [init_ret])
+
+        # Struct.[] is an alias for Struct.new
+        if @kind == :struct
+          # Struct.[] builds the struct class itself, not the base class
+          self_ret = @changes.add_escape_box(genv, Source.new(Type::Instance.new(genv, genv.resolve_cpath(@static_cpath), [])))
+          @changes.add_method_def_box(genv, cpath, true, :[], init_f_args, [self_ret])
+        end
+
+        # Install block body (additional method definitions)
+        if @block_body
+          @block_body.lenv.locals[:"*self"] = @block_body.lenv.cref.get_self(genv)
+          @block_body.install(genv)
+        end
+
+        mod_val
+      end
+    end
   end
 end