typeprof 0.31.1 → 0.32.0

data/lib/typeprof/core/ast.rb

@@ -1,6 +1,6 @@
 module TypeProf::Core
   class AST
-    def self.parse_rb(path, src)
+    def self.parse_rb(path, src, position_encoding)
       result = Prism.parse(src)
 
       return nil unless result.errors.empty?
@@ -10,19 +10,58 @@ module TypeProf::Core
 
       raise unless raw_scope.type == :program_node
 
-      Fiber[:comments] = result.comments
+      prism_source = result.source
+      file_context = FileContext.new(path, position_encoding, prism_source, result.comments)
 
       cref = CRef::Toplevel
-      lenv = LocalEnv.new(path, cref, {}, [])
+      lenv = LocalEnv.new(file_context, cref, {}, [])
 
-      ProgramNode.new(raw_scope, lenv)
+      ignore_ranges = collect_ignore_ranges(result)
+      ProgramNode.new(raw_scope, lenv, ignore_ranges: ignore_ranges)
     end
 
-    #: (untyped, TypeProf::Core::LocalEnv, ?bool) -> TypeProf::Core::AST::Node
-    def self.create_node(raw_node, lenv, use_result = true)
+    # Collect line ranges marked with `# typeprof:ignore` comments.
+    # Each range is suppressed in ProgramNode#each_diagnostic.
+    #
+    # Inline form (suppresses the line containing the comment):
+    #     foo(1, 2) # typeprof:ignore
+    #
+    # Block form (suppresses lines between :start and :end):
+    #     # typeprof:ignore:start
+    #     foo(1, 2)
+    #     # typeprof:ignore:end
+    #
+    # An unmatched `:start` extends to the end of the file.
+    IGNORE_RE       = /\A#\s*typeprof:ignore\s*\z/
+    IGNORE_START_RE = /\A#\s*typeprof:ignore:start\s*\z/
+    IGNORE_END_RE   = /\A#\s*typeprof:ignore:end\s*\z/
+    def self.collect_ignore_ranges(prism_result)
+      ranges = []
+      start_line = nil
+      prism_result.comments.each do |c|
+        text = c.location.slice
+        line = c.location.start_line
+        if text.match?(IGNORE_START_RE)
+          start_line ||= line
+        elsif text.match?(IGNORE_END_RE)
+          if start_line
+            ranges << (start_line..line)
+            start_line = nil
+          end
+        elsif text.match?(IGNORE_RE)
+          ranges << (line..line)
+        end
+      end
+      ranges << (start_line..Float::INFINITY) if start_line
+      ranges
+    end
+
+    #: (untyped, TypeProf::Core::LocalEnv, ?bool, ?bool) -> TypeProf::Core::AST::Node
+    def self.create_node(raw_node, lenv, use_result = true, allow_meta = false)
       while true
         case raw_node.type
         when :parentheses_node
+          return DummyNilNode.new(lenv.code_range_from_node(raw_node), lenv) if raw_node.body.nil?
           raw_node = raw_node.body
         when :implicit_node
           raw_node = raw_node.value
@@ -64,7 +103,13 @@ module TypeProf::Core
       when :constant_read_node, :constant_path_node
         ConstantReadNode.new(raw_node, lenv)
       when :constant_write_node, :constant_path_write_node
-        ConstantWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
+        if (members = detect_struct_new(raw_node.value))
+          StructNewNode.new(raw_node, members, :struct, lenv)
+        elsif (members = detect_data_define(raw_node.value))
+          StructNewNode.new(raw_node, members, :data, lenv)
+        else
+          ConstantWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
+        end
       when :constant_operator_write_node
         read = ConstantReadNode.new(raw_node, lenv)
         rhs = OperatorNode.new(raw_node, read, lenv)
@@ -132,6 +177,7 @@ module TypeProf::Core
       when :class_variable_operator_write_node
         read = ClassVariableReadNode.new(raw_node, lenv)
         rhs = OperatorNode.new(raw_node, read, lenv)
+        ClassVariableWriteNode.new(raw_node, rhs, lenv)
       when :class_variable_or_write_node
         read = ClassVariableReadNode.new(raw_node, lenv)
         rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
@@ -233,15 +279,20 @@ module TypeProf::Core
       when :forwarding_super_node then ForwardingSuperNode.new(raw_node, lenv)
       when :yield_node then YieldNode.new(raw_node, lenv)
       when :call_node
-        if !raw_node.receiver
-          # TODO: handle them only when it is directly under class or module
+        if allow_meta && !raw_node.receiver && !lenv.cref.mid && [:class, :metaclass].include?(lenv.cref.scope_level)
           case raw_node.name
           when :include
             return IncludeMetaNode.new(raw_node, lenv)
           when :attr_reader
             return AttrReaderMetaNode.new(raw_node, lenv)
+          when :attr_writer
+            return AttrWriterMetaNode.new(raw_node, lenv)
           when :attr_accessor
             return AttrAccessorMetaNode.new(raw_node, lenv)
+          when :module_function
+            if raw_node.arguments.nil?
+              return ModuleFunctionMetaNode.new(raw_node, lenv)
+            end
           end
         end
         CallNode.new(raw_node, lenv)
@@ -252,7 +303,7 @@ module TypeProf::Core
     end
 
     def self.create_target_node(raw_node, lenv)
-      dummy_node = DummyRHSNode.new(TypeProf::CodeRange.from_node(raw_node.location), lenv)
+      dummy_node = DummyRHSNode.new(lenv.code_range_from_node(raw_node.location), lenv)
       case raw_node.type
       when :local_variable_target_node
         LocalVariableWriteNode.new(raw_node, dummy_node, lenv)
@@ -305,7 +356,7 @@ module TypeProf::Core
       when :pinned_expression_node then PinnedPatternNode.new(raw_node, lenv)
 
       when :local_variable_target_node
-        dummy_node = DummyRHSNode.new(TypeProf::CodeRange.from_node(raw_node.location), lenv)
+        dummy_node = DummyRHSNode.new(lenv.code_range_from_node(raw_node.location), lenv)
         LocalVariableWriteNode.new(raw_node, dummy_node, lenv)
 
       when :constant_read_node, :constant_path_node
@@ -364,11 +415,12 @@ module TypeProf::Core
       return cpath + names.reverse if cpath
     end
 
-    def self.parse_rbs(path, src)
+    def self.parse_rbs(path, src, position_encoding)
       _buffer, _directives, raw_decls = RBS::Parser.parse_signature(src)
 
       cref = CRef::Toplevel
-      lenv = LocalEnv.new(path, cref, {}, [])
+      file_context = FileContext.new(path, position_encoding)
+      lenv = LocalEnv.new(file_context, cref, {}, [])
 
       raw_decls.map do |raw_decl|
         AST.create_rbs_decl(raw_decl, lenv)
@@ -385,7 +437,10 @@ module TypeProf::Core
         SigInterfaceNode.new(raw_decl, lenv)
       when RBS::AST::Declarations::Constant
         SigConstNode.new(raw_decl, lenv)
-      when RBS::AST::Declarations::AliasDecl
+      when RBS::AST::Declarations::ClassAlias
+        SigClassAliasNode.new(raw_decl, lenv)
+      when RBS::AST::Declarations::ModuleAlias
+        SigModuleAliasNode.new(raw_decl, lenv)
       when RBS::AST::Declarations::TypeAlias
         SigTypeAliasNode.new(raw_decl, lenv)
         # TODO: check
@@ -481,5 +536,31 @@ module TypeProf::Core
         raise "unknown RBS type: #{ raw_decl.class }"
       end
     end
+
+    def self.detect_struct_new(raw_value)
+      return nil unless raw_value.type == :call_node
+      return nil unless raw_value.name == :new
+      recv = raw_value.receiver
+      return nil unless recv&.type == :constant_read_node && recv.name == :Struct
+      extract_symbol_args(raw_value)
+    end
+
+    def self.detect_data_define(raw_value)
+      return nil unless raw_value.type == :call_node
+      return nil unless raw_value.name == :define
+      recv = raw_value.receiver
+      return nil unless recv&.type == :constant_read_node && recv.name == :Data
+      extract_symbol_args(raw_value)
+    end
+
+    def self.extract_symbol_args(raw_call)
+      return nil unless raw_call.arguments
+      members = []
+      raw_call.arguments.arguments.each do |arg|
+        return nil unless arg.type == :symbol_node
+        members << arg.value.to_sym
+      end
+      members
+    end
   end
 end

data/lib/typeprof/core/builtin.rb

@@ -69,6 +69,20 @@ module TypeProf::Core
         else
           false
         end
+      elsif a_args.positionals.size == 3
+        # ary[start, len] = val
+        # Use SplatBox to extract element types from the assigned value
+        elem_vtx = case ty
+        when Type::Array
+          ty.get_elem(@genv)
+        when Type::Instance
+          ty.mod == @genv.mod_ary ? ty.args[0] : nil
+        end
+        return false unless elem_vtx
+        val = a_args.positionals[2]
+        splat_ret = changes.add_splat_box(@genv, val).ret
+        changes.add_edge(@genv, splat_ret, elem_vtx)
+        true
       else
         false
       end
@@ -90,7 +104,7 @@ module TypeProf::Core
     def hash_aref(changes, node, ty, a_args, ret)
       if a_args.positionals.size == 1
         case ty
-        when Type::Hash, Type::Record
+        when Type::Hash
           idx = node.positional_args[0]
           idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
           value = ty.get_value(idx)
@@ -101,6 +115,20 @@ module TypeProf::Core
             changes.add_edge(@genv, Source.new(), ret)
           end
           true
+        when Type::Record
+          idx = node.positional_args[0]
+          idx = idx.is_a?(AST::SymbolNode) ? idx.lit : nil
+          value = ty.get_value(idx)
+          if value
+            changes.add_edge(@genv, value, ret)
+          else
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          # Symbol variable access - add nil possibility
+          if idx.nil?
+            changes.add_edge(@genv, Source.new(@genv.nil_type), ret)
+          end
+          true
         else
           false
         end
@@ -125,6 +153,15 @@ module TypeProf::Core
           end
           changes.add_edge(@genv, val, ret)
           true
+        when Type::Record
+          val = a_args.positionals[1]
+          idx = node.positional_args[0]
+          if idx.is_a?(AST::SymbolNode)
+            field_vtx = ty.get_value(idx.lit)
+            changes.add_edge(@genv, val, field_vtx) if field_vtx
+          end
+          changes.add_edge(@genv, val, ret)
+          true
         else
           false
         end
@@ -133,19 +170,154 @@ module TypeProf::Core
       end
     end
 
+    def object_method(changes, node, ty, a_args, ret)
+      if a_args.positionals.size == 1
+        sym_node = node.positional_args[0]
+        if sym_node.is_a?(AST::SymbolNode)
+          method_ty = Type::Method.new(@genv, ty, sym_node.lit)
+          changes.add_edge(@genv, Source.new(method_ty), ret)
+          return true
+        end
+      end
+      false
+    end
+
+    def method_call(changes, node, ty, a_args, ret)
+      case ty
+      when Type::Method
+        recv = Source.new(ty.recv_ty)
+        box = changes.add_method_call_box(@genv, recv, ty.mid, a_args, false)
+        changes.add_edge(@genv, box.ret, ret)
+        true
+      else
+        false
+      end
+    end
+
+    def kernel_send(changes, node, ty, a_args, ret)
+      return false if a_args.positionals.empty?
+
+      if a_args.splat_flags[0]
+        # send(*array) case: extract method name and args from array elements
+        splat_vtx = a_args.positionals[0]
+        changes.add_edge(@genv, splat_vtx, changes.target)
+
+        rest_positionals = a_args.positionals[1..]
+        rest_splat_flags = a_args.splat_flags[1..]
+
+        splat_vtx.each_type do |ary_ty|
+          next unless ary_ty.is_a?(Type::Array)
+
+          if ary_ty.elems && ary_ty.elems.size >= 1
+            # Tuple: use per-element precision
+            method_name_vtx = ary_ty.elems[0]
+            changes.add_edge(@genv, method_name_vtx, changes.target)
+
+            elem_args = ary_ty.elems[1..] + rest_positionals
+            elem_flags = ::Array.new(ary_ty.elems.size - 1, false) + rest_splat_flags
+            send_a_args = ActualArguments.new(elem_args, elem_flags, a_args.keywords, a_args.block)
+
+            method_name_vtx.each_type do |sym_ty|
+              if sym_ty.is_a?(Type::Symbol)
+                recv = Source.new(ty)
+                box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+                changes.add_edge(@genv, box.ret, ret)
+              end
+            end
+          else
+            # Non-tuple array: use unified element type for method name
+            elem_vtx = ary_ty.get_elem(@genv)
+            next unless elem_vtx
+            changes.add_edge(@genv, elem_vtx, changes.target)
+
+            send_a_args = ActualArguments.new(rest_positionals, rest_splat_flags, a_args.keywords, a_args.block)
+
+            elem_vtx.each_type do |sym_ty|
+              if sym_ty.is_a?(Type::Symbol)
+                recv = Source.new(ty)
+                box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+                changes.add_edge(@genv, box.ret, ret)
+              end
+            end
+          end
+        end
+      else
+        # send(:sym, ...) case
+        changes.add_edge(@genv, a_args.positionals[0], changes.target)
+        send_a_args = ActualArguments.new(
+          a_args.positionals[1..],
+          a_args.splat_flags[1..],
+          a_args.keywords,
+          a_args.block,
+        )
+        a_args.positionals[0].each_type do |sym_ty|
+          if sym_ty.is_a?(Type::Symbol)
+            recv = Source.new(ty)
+            box = changes.add_method_call_box(@genv, recv, sym_ty.sym, send_a_args, false)
+            changes.add_edge(@genv, box.ret, ret)
+          end
+        end
+      end
+      true
+    end
+
+    def kernel_array(changes, node, ty, a_args, ret)
+      return false unless a_args.positionals.size == 1
+
+      arg_vtx = a_args.positionals[0]
+      elem_vtx = Vertex.new(node)
+      handled = false
+      needs_elem_wrap = false
+
+      arg_vtx.each_type do |arg_ty|
+        handled = true
+        case arg_ty
+        when Type::Instance
+          if arg_ty.mod == @genv.mod_range && arg_ty.args && !arg_ty.args.empty?
+            changes.add_edge(@genv, arg_ty.args[0], elem_vtx)
+            needs_elem_wrap = true
+          elsif arg_ty.mod == @genv.mod_ary
+            changes.add_edge(@genv, Source.new(arg_ty), ret)
+          else
+            changes.add_edge(@genv, Source.new(arg_ty), elem_vtx)
+            needs_elem_wrap = true
+          end
+        when Type::Array
+          changes.add_edge(@genv, Source.new(arg_ty), ret)
+        else
+          changes.add_edge(@genv, Source.new(arg_ty), elem_vtx)
+          needs_elem_wrap = true
+        end
+      end
+
+      return false unless handled
+
+      if needs_elem_wrap
+        ary_ty = @genv.gen_ary_type(elem_vtx)
+        changes.add_edge(@genv, Source.new(ary_ty), ret)
+      end
+      true
+    end
+
     def deploy
-      {
-        class_new: [[:Class], false, :new],
-        object_class: [[:Object], false, :class],
-        proc_call: [[:Proc], false, :call],
-        array_aref: [[:Array], false, :[]],
-        array_aset: [[:Array], false, :[]=],
-        array_push: [[:Array], false, :<<],
-        hash_aref: [[:Hash], false, :[]],
-        hash_aset: [[:Hash], false, :[]=],
-      }.each do |key, (cpath, singleton, mid)|
+      [
+        [method(:class_new), [:Class], false, :new],
+        [method(:object_class), [:Object], false, :class],
+        [method(:proc_call), [:Proc], false, :call],
+        [method(:array_aref), [:Array], false, :[]],
+        [method(:array_aset), [:Array], false, :[]=],
+        [method(:array_push), [:Array], false, :<<],
+        [method(:hash_aref), [:Hash], false, :[]],
+        [method(:hash_aset), [:Hash], false, :[]=],
+        [method(:object_method), [:Kernel], false, :method],
+        [method(:method_call), [:Method], false, :call],
+        [method(:kernel_send), [:BasicObject], false, :__send__],
+        [method(:kernel_send), [:Kernel], false, :public_send],
+        [method(:kernel_send), [:Kernel], false, :send],
+        [method(:kernel_array), [:Kernel], false, :Array],
+      ].each do |builtin, cpath, singleton, mid|
         me = @genv.resolve_method(cpath, singleton, mid)
-        me.builtin = method(key)
+        me.builtin = builtin
       end
     end
   end

data/lib/typeprof/core/env/method.rb

@@ -41,6 +41,17 @@ module TypeProf::Core
       ActualArguments.new(positionals, splat_flags, keywords, block)
     end
 
+    def with_keywords_as_last_positional_hash
+      return self unless @keywords
+
+      ActualArguments.new(
+        @positionals + [@keywords],
+        @splat_flags + [false],
+        nil,
+        @block
+      )
+    end
+
     def get_rest_args(genv, changes, start_rest, end_rest)
       vtxs = []
 
@@ -69,6 +80,9 @@ module TypeProf::Core
         case ty
         when Type::Hash
           changes.add_edge(genv, ty.get_value(name), vtx)
+        when Type::Record
+          field_vtx = ty.get_value(name)
+          changes.add_edge(genv, field_vtx, vtx) if field_vtx
         when Type::Instance
           if ty.mod == genv.mod_hash
             changes.add_edge(genv, ty.args[1], vtx)
@@ -81,6 +95,162 @@ module TypeProf::Core
     end
   end
 
+  class ForwardingArguments
+    def initialize(req_positionals, opt_positionals, opt_positional_elems, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block)
+      @req_positionals = req_positionals
+      @opt_positionals = opt_positionals
+      @opt_positional_elems = opt_positional_elems
+      @rest_positionals = rest_positionals
+      @post_positionals = post_positionals
+      @req_keyword_pairs = req_keyword_pairs
+      @opt_keyword_pairs = opt_keyword_pairs
+      @rest_keywords = rest_keywords
+      @block = block
+    end
+
+    attr_reader :block
+
+    def to_actual_arguments(genv, changes, node)
+      positionals = @req_positionals.dup
+      splat_flags = ::Array.new(positionals.size, false)
+
+      @opt_positionals.each do |arg|
+        positionals << arg
+        splat_flags << true
+      end
+
+      if @rest_positionals
+        positionals << @rest_positionals
+        splat_flags << true
+      end
+
+      @post_positionals.each do |arg|
+        positionals << arg
+        splat_flags << false
+      end
+
+      keywords = build_keyword_args(genv, changes, node)
+      ActualArguments.new(positionals, splat_flags, keywords, @block)
+    end
+
+    def accept_actual_arguments(genv, changes, a_args)
+      if a_args.splat_flags.any?
+        start_rest = [a_args.splat_flags.index(true), @req_positionals.size + @opt_positionals.size].min
+        end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @post_positionals.size].max
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+
+        @opt_positional_elems.each_with_index do |elem_vtx, i|
+          i += @req_positionals.size
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], elem_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, elem_vtx)
+            end
+          end
+        end
+
+        @post_positionals.each_with_index do |f_vtx, i|
+          i += a_args.positionals.size - @post_positionals.size
+          if end_rest <= i
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+
+      else
+        @req_positionals.each_with_index do |f_vtx, i|
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+
+        @post_positionals.each_with_index do |f_vtx, i|
+          i -= @post_positionals.size
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+
+        start_rest = @req_positionals.size
+        end_rest = a_args.positionals.size - @post_positionals.size
+        i = 0
+        while i < @opt_positional_elems.size && start_rest < end_rest
+          changes.add_edge(genv, a_args.positionals[start_rest], @opt_positional_elems[i])
+          i += 1
+          start_rest += 1
+        end
+      end
+
+      changes.add_edge(genv, a_args.block, @block) if @block && a_args.block
+
+      return unless a_args.keywords
+
+      @req_keyword_pairs.each do |name, f_vtx|
+        changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+      end
+
+      @opt_keyword_pairs.each do |name, f_vtx|
+        changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+      end
+
+      if @rest_keywords
+        named_keys = @req_keyword_pairs.map(&:first) + @opt_keyword_pairs.map(&:first)
+        a_args.keywords.each_type do |kw_ty|
+          case kw_ty
+          when Type::Record
+            rest_fields = kw_ty.fields.reject {|key, _| named_keys.include?(key) }
+            base = kw_ty.base_type(genv)
+            rest_record = Type::Record.new(genv, rest_fields, base)
+            changes.add_edge(genv, Source.new(rest_record), @rest_keywords)
+          when Type::Hash, Type::Instance
+            changes.add_edge(genv, Source.new(kw_ty), @rest_keywords)
+          end
+        end
+      end
+    end
+
+    private
+
+    def build_keyword_args(genv, changes, node)
+      return nil if @req_keyword_pairs.empty? && @opt_keyword_pairs.empty? && !@rest_keywords
+      return @rest_keywords if @req_keyword_pairs.empty? && @opt_keyword_pairs.empty?
+
+      unified_key = Vertex.new(node)
+      unified_val = Vertex.new(node)
+      literal_pairs = {}
+
+      @req_keyword_pairs.each do |name, vtx|
+        changes.add_edge(genv, Source.new(Type::Symbol.new(genv, name)), unified_key)
+        changes.add_edge(genv, vtx, unified_val)
+        literal_pairs[name] = vtx
+      end
+
+      @opt_keyword_pairs.each do |name, vtx|
+        changes.add_edge(genv, Source.new(Type::Symbol.new(genv, name)), unified_key)
+        changes.add_edge(genv, vtx, unified_val)
+      end
+
+      base_hash_type = genv.gen_hash_type(unified_key, unified_val)
+      changes.add_hash_splat_box(genv, @rest_keywords, unified_key, unified_val) if @rest_keywords
+
+      if literal_pairs.empty?
+        Source.new(base_hash_type)
+      else
+        Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
+      end
+    end
+  end
+
   class Block
     #: (AST::CallBaseNode, Vertex, Array[Vertex], Array[EscapeBox]) -> void
     def initialize(node, f_ary_arg, f_args, next_boxes)
@@ -94,12 +264,7 @@ module TypeProf::Core
 
     def accept_args(genv, changes, caller_positionals)
       if caller_positionals.size == 1 && @f_args.size >= 2
-        single_arg = caller_positionals[0]
-
-        @f_args.each_with_index do |f_arg, i|
-          elem_vtx = changes.add_splat_box(genv, single_arg, i).ret
-          changes.add_edge(genv, elem_vtx, f_arg)
-        end
+        changes.add_edge(genv, caller_positionals[0], @f_ary_arg)
       else
         caller_positionals.zip(@f_args) do |a_arg, f_arg|
           changes.add_edge(genv, a_arg, f_arg) if f_arg