typeprof 0.31.1 → 0.33.0

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

@@ -46,7 +46,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -63,11 +63,24 @@ module TypeProf::Core
         val
       end
 
+      def install_pattern0(genv, subject)
+        install0(genv)
+        @changes.add_edge(genv, subject, @rhs.ret)
+        subject
+      end
+
       def retrieve_at(pos, &blk)
         yield self if @var_code_range && @var_code_range.include?(pos)
         super(pos, &blk)
       end
 
+      def narrowings
+        @narrowings ||= [
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(false) }),
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(true) }),
+        ]
+      end
+
       def modified_vars(tbl, vars)
         vars << self.var if tbl.include?(self.var)
       end
@@ -109,7 +122,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -191,7 +204,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -264,7 +277,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 

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,22 @@ 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 :extend
+            return ExtendMetaNode.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 +305,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 +358,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 +417,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 +439,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
@@ -405,6 +462,7 @@ module TypeProf::Core
       when RBS::AST::Members::Prepend
         SigPrependNode.new(raw_decl, lenv)
       when RBS::AST::Members::Extend
+        SigExtendNode.new(raw_decl, lenv)
       when RBS::AST::Members::Public
       when RBS::AST::Members::Private
       when RBS::AST::Members::Alias
@@ -481,5 +539,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