typeprof 0.32.0 → 0.33.0

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

@@ -9,6 +9,8 @@ module TypeProf::Core
       @include_defs = Set.empty
       @prepend_decls = []
       @prepend_defs = []
+      @extend_decls = Set.empty
+      @extend_defs = Set.empty
 
       # `class Foo = Bar` / `module Foo = Bar` declarations attached to this entity.
       # Maps an alias decl to the target ModuleEntity at the time of registration.
@@ -23,6 +25,7 @@ module TypeProf::Core
       @self_types = {}
       @included_modules = {}
       @prepended_modules = {}
+      @extended_modules = {}
       @basic_object = @cpath == [:BasicObject]
 
       # child modules (subclasses and all modules that include me)
@@ -57,6 +60,7 @@ module TypeProf::Core
     attr_reader :self_types
     attr_reader :included_modules
     attr_reader :prepended_modules
+    attr_reader :extended_modules
     attr_reader :child_modules
 
     attr_reader :superclass_type_args
@@ -219,6 +223,26 @@ module TypeProf::Core
       genv.add_static_eval_queue(:parent_modules_changed, self)
     end
 
+    def add_extend_decl(genv, node)
+      @extend_decls << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_extend_decl(genv, node)
+      @extend_decls.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def add_extend_def(genv, node)
+      @extend_defs << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_extend_def(genv, node)
+      @extend_defs.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
     def add_prepend_decl(genv, node)
       @prepend_decls << node
       genv.add_static_eval_queue(:parent_modules_changed, self)
@@ -285,7 +309,8 @@ module TypeProf::Core
           when AST::ModuleNode
             return nil
           when AST::StructNewNode
-            return []  # inherits from Object (Struct < Object)
+            base_cpath = mdef.struct_base_cpath
+            return base_cpath == @cpath ? [] : base_cpath
           else
             raise
           end
@@ -396,6 +421,30 @@ module TypeProf::Core
           any_updated = true
         end
       end
+      @extend_decls.each do |edecl|
+        new_parent_cpath = edecl.static_ret.last.cpath
+        new_parent, updated = update_parent(genv, edecl, @extended_modules[edecl], new_parent_cpath)
+        if updated
+          if new_parent
+            @extended_modules[edecl] = new_parent
+          else
+            @extended_modules.delete(edecl) || raise
+          end
+          any_updated = true
+        end
+      end
+      @extend_defs.each do |edef|
+        new_parent_cpath = edef.static_ret ? edef.static_ret.cpath : nil
+        new_parent, updated = update_parent(genv, edef, @extended_modules[edef], new_parent_cpath)
+        if updated
+          if new_parent
+            @extended_modules[edef] = new_parent
+          else
+            @extended_modules.delete(edef) || raise
+          end
+          any_updated = true
+        end
+      end
       @included_modules.delete_if do |origin, old_mod|
         if @include_decls.include?(origin) || @include_defs.include?(origin)
           false
@@ -414,6 +463,15 @@ module TypeProf::Core
           true
         end
       end
+      @extended_modules.delete_if do |origin, old_mod|
+        if @extend_decls.include?(origin) || @extend_defs.include?(origin)
+          false
+        else
+          _new_parent, updated = update_parent(genv, origin, old_mod, nil)
+          any_updated ||= updated
+          true
+        end
+      end
 
       if any_updated
         @subclass_checks.each do |mcall_box|
@@ -424,6 +482,8 @@ module TypeProf::Core
     end
 
     def on_ancestors_updated(genv, base_mod)
+      # `include` and `extend` can form a cycle in valid Ruby
+      return if base_mod == self
       @child_modules.each_key {|child_mod| child_mod.on_ancestors_updated(genv, base_mod || self) }
       @static_reads.each_value do |static_reads|
         static_reads.each do |static_read|

data/lib/typeprof/core/env.rb

@@ -80,7 +80,7 @@ module TypeProf::Core
         # TODO: prepended modules
         yield mod, singleton
         if singleton
-          # TODO: extended modules
+          each_extended_module(mod, &blk)
         else
           each_included_module(mod, &blk)
         end
@@ -95,6 +95,15 @@ module TypeProf::Core
       end
     end
 
+    def each_extended_module(mod, &blk)
+      # An extended module contributes its instance methods (singleton = false)
+      # as the receiver's singleton methods.
+      mod.extended_modules.each do |_ext_decl, ext_mod|
+        yield ext_mod, false
+        each_included_module(ext_mod, &blk)
+      end
+    end
+
     def get_superclass(singleton, mod)
       super_mod = mod.superclass
       if super_mod
@@ -106,6 +115,9 @@ module TypeProf::Core
           else
             return nil
           end
+        elsif mod == @mod_object
+          # Unresolved while loading the core RBS; the Module fallback below would cycle
+          return [singleton, @mod_basic_object]
         elsif mod == @mod_module && !singleton
           return nil
         else
@@ -271,6 +283,17 @@ module TypeProf::Core
       mod.get_type_alias(name)
     end
 
+    # Returns the type parameter names of the first generic declaration of cpath
+    def find_type_params(decls, cpath)
+      decls.each do |decl|
+        next unless decl.cpath == cpath
+        next unless decl.respond_to?(:params)
+        params = decl.params
+        return params if params && !params.empty?
+      end
+      nil
+    end
+
     def load_core_rbs(raw_decls, position_encoding)
       file_context = FileContext.new(nil, position_encoding)
       lenv = LocalEnv.new(file_context, CRef::Toplevel, {}, [])
@@ -278,6 +301,11 @@ module TypeProf::Core
         AST.create_rbs_decl(raw_decl, lenv)
       end.compact
 
+      # A module entity has one set of parameter names shared by all its declarations,
+      # so the shim must reuse the core's ones (Array's was `Elem`, and is `E` since RBS 4.1)
+      ary_elem, = find_type_params(decls, [:Array]) || [:Elem]
+      hash_key, hash_val = find_type_params(decls, [:Hash]) || [:K, :V]
+
       decls += AST.parse_rbs("typeprof-rbs-shim.rbs", <<-RBS, position_encoding)
         class Exception
           include _Exception
@@ -286,12 +314,12 @@ module TypeProf::Core
           include _ToS
           include _ToStr
         end
-        class Array[Elem]
-          include _ToAry[Elem]
-          include _Each[Elem]
+        class Array[#{ ary_elem }]
+          include _ToAry[#{ ary_elem }]
+          include _Each[#{ ary_elem }]
         end
-        class Hash[K, V]
-          include _Each[[K, V]]
+        class Hash[#{ hash_key }, #{ hash_val }]
+          include _Each[[#{ hash_key }, #{ hash_val }]]
         end
         class Object
           include Hash::_Key

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

@@ -405,7 +405,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 +458,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 +483,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 +503,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 +523,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.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.33.0
 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: []