typeprof 0.32.0 → 0.33.1

data/lib/typeprof/core/graph/box.rb

@@ -17,6 +17,7 @@ module TypeProf::Core
       $box_counts[self.class] -= 1
       $box_counts[Box] -= 1
       @destroyed = true
+      destroy_symbol_proc_call_boxes(genv)
       @changes.reinstall(genv) # rollback all changes
     end
 
@@ -43,6 +44,24 @@ module TypeProf::Core
       raise NotImplementedError
     end
 
+    def add_symbol_proc_call_box(_changes, genv, sym, caller_positionals, caller_keywords = nil)
+      return if caller_positionals.empty?
+
+      recv = caller_positionals.first
+      positionals = caller_positionals[1..]
+      @symbol_proc_call_boxes ||= {}
+      @symbol_proc_call_boxes[[recv, sym, *positionals, caller_keywords]] ||= begin
+        a_args = ActualArguments.new(positionals, ::Array.new(positionals.size, false), caller_keywords, nil)
+        MethodCallBox.new(@node, genv, recv, sym, a_args, false)
+      end
+    end
+
+    def destroy_symbol_proc_call_boxes(genv)
+      return unless @symbol_proc_call_boxes
+      @symbol_proc_call_boxes.each_value { |box| box.destroy(genv) }
+      @symbol_proc_call_boxes = nil
+    end
+
     def to_s
       "#{ self.class.to_s.split("::").last }#{ @id ||= $new_id += 1 }"
     end
@@ -127,6 +146,12 @@ module TypeProf::Core
       }
     end
 
+    # lazy cache: overloads split into fixed-arity ones and rest-positional ones
+    def partition_by_rest_positionals
+      @partition_by_rest_positionals ||=
+        @method_types.partition {|method_type| !method_type.rest_positionals }
+    end
+
     private
 
     # Check if two method types have structurally identical positional
@@ -258,6 +283,7 @@ module TypeProf::Core
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.remove_decl(self)
       me.add_run_all_method_call_boxes(genv)
+      destroy_symbol_proc_call_boxes(genv)
     end
 
     def match_arguments?(genv, changes, param_map, a_args, method_type)
@@ -382,6 +408,8 @@ module TypeProf::Core
                 end
               end
             end
+          when Type::Symbol
+            resolve_symbol_proc(changes, genv, ty.sym, blk_a_args, rbs_blk, param_map0)
           end
         end
       end
@@ -396,6 +424,13 @@ module TypeProf::Core
       end
     end
 
+    def resolve_symbol_proc(changes, genv, sym, blk_a_args, rbs_blk, param_map)
+      box = add_symbol_proc_call_box(changes, genv, sym, blk_a_args)
+      return unless box
+
+      rbs_blk.return_type.typecheck(genv, changes, box.ret, param_map)
+    end
+
     def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
       if @method_types.size == 1
         method_type = @method_types.first
@@ -451,11 +486,19 @@ module TypeProf::Core
         return
       end
 
+      # A splatted call can match only a rest-positional overload; otherwise prefer
+      # the fixed-arity ones, as a rest-positional one is usually a catch-all
+      overload_groups =
+        a_args.splat_flags.any? ? [@method_types] : @method_types.partition_by_rest_positionals
+
       match_any_overload = false
-      @method_types.each do |method_type|
-        if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
-          match_any_overload = true
+      overload_groups.each do |method_types|
+        method_types.each do |method_type|
+          if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
+            match_any_overload = true
+          end
         end
+        break if match_any_overload
       end
       unless match_any_overload
         meth = node.mid_code_range ? :mid_code_range : :code_range
@@ -600,13 +643,13 @@ module TypeProf::Core
   end
 
   class SplatBox < Box
-    def initialize(node, genv, ary, idx, orig = nil)
+    def initialize(node, genv, ary, idx, unresolved_recv = nil)
       super(node)
       @ary = ary
       @idx = idx
-      @orig = orig
+      @unresolved_recv = unresolved_recv
       @ary.add_edge(genv, self)
-      @orig.add_edge(genv, self) if @orig
+      @unresolved_recv.add_edge(genv, self) if @unresolved_recv
       @ret = Vertex.new(node)
     end
 
@@ -632,14 +675,41 @@ module TypeProf::Core
         end
       end
       # For types where to_a is not defined, [*x] wraps x as [x]
-      if @orig && @ary.types.empty?
-        @orig.each_type do |ty|
+      if @unresolved_recv
+        @unresolved_recv.each_type do |ty|
           changes.add_edge(genv, Source.new(ty), @ret)
         end
       end
     end
   end
 
+  # Merges the keywords being forwarded into the `**rest` hash while keeping the
+  # rest's own fields, so that the callee can still tell the two apart.
+  class KeywordMergeBox < Box
+    def initialize(node, genv, rest, literal_pairs, fallback)
+      super(node)
+      @rest = rest
+      @literal_pairs = literal_pairs
+      @fallback = fallback
+      @rest.add_edge(genv, self)
+      @ret = Vertex.new(node)
+    end
+
+    attr_reader :ret
+
+    def run0(genv, changes)
+      merged = false
+      @rest.each_type do |ty|
+        if ty.is_a?(Type::Record)
+          fields = ty.fields.merge(@literal_pairs)
+          changes.add_edge(genv, Source.new(Type::Record.new(genv, fields, ty.base_type(genv))), @ret)
+          merged = true
+        end
+      end
+      changes.add_edge(genv, @fallback, @ret) unless merged
+    end
+  end
+
   class HashSplatBox < Box
     def initialize(node, genv, hsh, unified_key, unified_val)
       super(node)
@@ -1004,29 +1074,42 @@ module TypeProf::Core
   end
 
   class MethodCallBox < Box
-    def initialize(node, genv, recv, mid, a_args, subclasses, suppress_errors: false)
+    # `unresolved_recv`, when given, collects the receiver types for which no
+    # method entity was found. Without it those types only become "undefined
+    # method" diagnostics; with it the caller can handle them itself, as `[*x]`
+    # does to wrap a receiver that has no `to_a`.
+    def initialize(node, genv, recv, mid, a_args, subclasses, suppress_errors: false, unresolved_recv: nil)
       raise mid.to_s unless mid
       super(node)
       @recv = recv.new_vertex(genv, node)
       @recv.add_edge(genv, self)
       @mid = mid
       @a_args = a_args.new_vertexes(genv, node)
-      @a_args.keywords.add_edge(genv, self) if @a_args.keywords
-      @a_args.block.add_edge(genv, self) if @a_args.block
+      @a_args.add_box_edges(genv, self)
       @ret = Vertex.new(node)
       @subclasses = subclasses
       @suppress_errors = suppress_errors
+      @unresolved_recv = unresolved_recv
       @generics = {}
     end
 
     attr_reader :recv, :mid, :ret
 
     def run0(genv, changes)
+      a_args = @a_args.normalize_for_method_call(genv)
+      return unless a_args
+
       edges = Set.empty
       called_mdefs = Set.empty
       error_count = 0
       resolve(genv, changes) do |me, ty, mid, orig_ty|
-        if !me
+        if @node.is_a?(AST::YieldNode) && mid == :call && orig_ty.is_a?(Type::Symbol)
+          box = add_symbol_proc_call_box(changes, genv, orig_ty.sym, a_args.positionals, a_args.keywords)
+          changes.add_edge(genv, box.ret, @ret) if box
+        elsif !me
+          if @unresolved_recv
+            changes.add_edge(genv, Source.new(orig_ty), @unresolved_recv)
+          end
           unless @suppress_errors
             if error_count < 3
               meth = @node.mid_code_range ? :mid_code_range : :code_range
@@ -1034,7 +1117,7 @@ module TypeProf::Core
             end
           end
           error_count += 1
-        elsif me.builtin && me.builtin[changes, @node, orig_ty, @a_args, @ret]
+        elsif me.builtin && me.builtin[changes, @node, orig_ty, a_args, @ret]
           # do nothing
         elsif !me.decls.empty?
           # TODO: support "| ..."
@@ -1047,7 +1130,7 @@ module TypeProf::Core
                 ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(genv, changes, ty_env) : Source.new)
               end
             end
-            mdecl.resolve_overloads(changes, genv, @node, ty_env, @a_args, @ret) do |method_type|
+            mdecl.resolve_overloads(changes, genv, @node, ty_env, a_args, @ret) do |method_type|
               @generics[method_type] ||= method_type.type_params.map { Vertex.new(@node) }
             end
           end
@@ -1055,7 +1138,7 @@ module TypeProf::Core
           me.defs.each do |mdef|
             next if called_mdefs.include?(mdef)
             called_mdefs << mdef
-            mdef.call(changes, genv, @a_args, @ret)
+            mdef.call(changes, genv, a_args, @ret)
           end
         else
           pp me
@@ -1068,7 +1151,7 @@ module TypeProf::Core
             me.defs.each do |mdef|
               next if called_mdefs.include?(mdef)
               called_mdefs << mdef
-              mdef.call(changes, genv, @a_args, @ret)
+              mdef.call(changes, genv, a_args, @ret)
             end
           end
         end
@@ -1126,7 +1209,10 @@ module TypeProf::Core
           skip = false
 
           if ty.is_a?(Type::Singleton)
-            # TODO: extended modules
+            # Check extended modules (their instance methods are singleton methods here)
+            break if resolve_extended_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
+              yield me, ty, mid, orig_ty
+            end
           else
             # Finally check included modules
             break if resolve_included_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
@@ -1226,6 +1312,38 @@ module TypeProf::Core
       found
     end
 
+    def resolve_extended_modules(genv, changes, base_ty_env, ty, mid, &blk)
+      found = false
+
+      alias_limit = 0
+      # An extended module's instance methods are resolved as the receiver's
+      # singleton methods, so look them up with singleton = false.
+      ty.mod.extended_modules.each do |ext_decl, ext_mod|
+        if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
+          ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, base_ty_env, ty)
+        else
+          type_params = ext_mod.type_params.map { Source.new() } # TODO: better support
+          ext_ty = Type::Instance.new(genv, ext_mod, type_params)
+        end
+
+        me = ext_ty.mod.get_method(false, mid)
+        changes.add_depended_method_entity(me) if changes
+        if !me.aliases.empty?
+          mid = me.aliases.values.first
+          alias_limit += 1
+          redo if alias_limit < 5
+        end
+        if me.exist?
+          found = true
+          yield me, ext_ty, mid
+        else
+          # The extended module may itself include other modules.
+          found ||= resolve_included_modules(genv, changes, base_ty_env, ext_ty, mid, &blk)
+        end
+      end
+      found
+    end
+
     def resolve_subclasses(genv, changes)
       # TODO: This does not follow new subclasses
       @recv.each_type do |ty|

data/lib/typeprof/core/graph/change_set.rb

@@ -71,9 +71,9 @@ module TypeProf::Core
 
     # TODO: if an edge is removed during one analysis, we may need to remove sub-boxes?
 
-    def add_method_call_box(genv, recv, mid, a_args, subclasses, suppress_errors: false)
-      key = [:mcall, recv, mid, a_args, subclasses, suppress_errors]
-      new_boxes[key] ||= MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses, suppress_errors: suppress_errors)
+    def add_method_call_box(genv, recv, mid, a_args, subclasses, suppress_errors: false, unresolved_recv: nil)
+      key = [:mcall, recv, mid, a_args, subclasses, suppress_errors, unresolved_recv]
+      new_boxes[key] ||= MethodCallBox.new(@node, genv, recv, mid, a_args, subclasses, suppress_errors: suppress_errors, unresolved_recv: unresolved_recv)
     end
 
     def add_escape_box(genv, a_ret)
@@ -81,9 +81,14 @@ module TypeProf::Core
       new_boxes[key] ||= EscapeBox.new(@node, genv, a_ret)
     end
 
-    def add_splat_box(genv, arg, idx = nil, orig = nil)
-      key = [:splat, arg, idx, orig]
-      new_boxes[key] ||= SplatBox.new(@node, genv, arg, idx, orig)
+    def add_splat_box(genv, arg, idx = nil, unresolved_recv = nil)
+      key = [:splat, arg, idx, unresolved_recv]
+      new_boxes[key] ||= SplatBox.new(@node, genv, arg, idx, unresolved_recv)
+    end
+
+    def add_keyword_merge_box(genv, rest, literal_pairs, fallback)
+      key = [:kw_merge, rest, literal_pairs, fallback]
+      new_boxes[key] ||= KeywordMergeBox.new(@node, genv, rest, literal_pairs, fallback)
     end
 
     def add_hash_splat_box(genv, arg, unified_key, unified_val)

data/lib/typeprof/core/service.rb

@@ -55,10 +55,15 @@ module TypeProf::Core
     end
 
     def update_rb_file(path, code)
+      code = File.read(path) unless code
+      update_rb_ast(path, Prism.parse(code))
+    end
+
+    # path is used only as a key to find the previous analysis; the file is not read.
+    def update_rb_ast(path, parse_result)
       prev_node = @rb_text_nodes[path]
 
-      code = File.read(path) unless code
-      node = AST.parse_rb(path, code, @options[:position_encoding])
+      node = AST.build_rb(path, parse_result, @options[:position_encoding])
       return false unless node
 
       node.diff(@rb_text_nodes[path]) if prev_node
@@ -405,7 +410,9 @@ module TypeProf::Core
                     break
                   end
                 end
-                yield mid, "#{ mod.cpath.join("::" )}#{ singleton ? "." : "#" }#{ mid } : #{ sig }" if sig
+                # The base class has no name to show
+                owner = mod.cpath.last == AST::StructNewNode::BASE_CNAME ? base_ty.mod : mod
+                yield mid, "#{ owner.cpath.join("::" )}#{ singleton ? "." : "#" }#{ mid } : #{ sig }" if sig
               end
             end
           end
@@ -456,6 +463,7 @@ module TypeProf::Core
     def dump_declarations(path)
       stack = []
       out = []
+      seen_consts = Set.empty
       @rb_text_nodes[path]&.traverse do |event, node|
         case node
         when AST::ModuleNode
@@ -480,6 +488,10 @@ module TypeProf::Core
               s = "class #{ format_declared_const_path(node.static_cpath, stack) }"
               mod = @genv.resolve_cpath(node.static_cpath)
               superclass = mod.superclass
+              # The base class is not shown; its members are printed inline
+              while superclass && superclass.cpath.last == AST::StructNewNode::BASE_CNAME
+                superclass = superclass.superclass
+              end
               if superclass == nil
                 s << " # failed to identify its superclass"
               elsif superclass.cpath != []
@@ -496,8 +508,16 @@ module TypeProf::Core
                   out << "  " * stack.size + "include #{ inc_mod.show_cpath }"
                 end
               end
+              mod.extended_modules.each do |ext_def, ext_mod|
+                if ext_def.is_a?(AST::ConstantReadNode) && ext_def.lenv.path == path
+                  out << "  " * stack.size + "extend #{ ext_mod.show_cpath }"
+                end
+              end
               # Output method definitions from meta nodes (StructNewNode etc.)
               node.boxes(:mdef) do |mdef|
+                # A user-written method overrides the generated one
+                next if node.is_a?(AST::StructNewNode) &&
+                        !@genv.resolve_method(node.static_cpath, mdef.singleton, mdef.mid).defs.empty?
                 out << "  " * stack.size + "def #{ mdef.singleton ? "self." : "" }#{ mdef.mid }: " + mdef.show(@options[:output_parameter_names])
               end
             else
@@ -508,7 +528,14 @@ module TypeProf::Core
         when AST::ConstantWriteNode
           if node.static_cpath
             if event == :enter
-              out << "  " * stack.size + "#{ format_declared_const_path(node.static_cpath, stack) }: #{ node.ret.show }"
+              unless seen_consts.include?(node.static_cpath)
+                seen_consts << node.static_cpath
+                cdef = @genv.resolve_const(node.static_cpath)
+                # Use the assigned value for a single write so a same-named class
+                # or module (e.g. declared in RBS) is not mixed in; union the types otherwise.
+                ret = cdef.defs.size > 1 ? cdef.vtx : node.ret
+                out << "  " * stack.size + "#{ format_declared_const_path(node.static_cpath, stack) }: #{ ret.show }"
+              end
             end
           end
         else

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.32.0"
+  VERSION = "0.33.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.33.1
 platform: ruby
 authors:
 - Yusuke Endoh
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation
 test_files: []