rigortype 0.4.4 → 0.4.5

data/lib/rigor/inference/self_call_ivar_writes.rb

@@ -139,10 +139,11 @@ module Rigor
         # Issue #1596 — gives up when `self`'s class, a project subclass, or a project ancestor or module on either's
         # chain defines a {PROTOCOL_NAMES} method (a `def`, `define_method`, `attr_*` or alias), rewrites its methods
         # beyond the names it spells, or is refined on one; or when either chain holds an external ancestor, whose
-        # own definitions the read cannot see.
+        # own definitions the read cannot see. Issue #1979 — a class built on a core constructor call
+        # (`class Fact < Data.define(:a)`) cannot be `self`'s class or a subclass of it, so the walk leaves it out.
         def no_protocol_override
           classes = [@class_name]
-          RefinedDispatch::OwnMethod.each_subclass(@scope, @class_name) { |subclass| classes << subclass }
+          RefinedDispatch::OwnMethod.each_subclass(@scope, @class_name, possible_only: true) { |subclass| classes << subclass }
           classes.each do |class_name|
             chain = Scope::ResolutionChain.for(@scope, class_name.to_s, :instance, :methods)
             unprovable! if chain.truncated? || chain.wildcard_mixin? || !settled?(chain)
@@ -229,7 +230,7 @@ module Rigor
 
           # A subclass whose superclass the tables do not know is enumerated too, and its chain ends short of the
           # owner; one that reaches no definer of its own leaves the call to its superclass.
-          RefinedDispatch::OwnMethod.each_subclass(@scope, @class_name) do |subclass|
+          RefinedDispatch::OwnMethod.each_subclass(@scope, @class_name, possible_only: true) do |subclass|
             unprovable! unless [owner, nil].include?(definer_ahead(subclass, name, owner))
           end
           def_node
@@ -258,9 +259,11 @@ module Rigor
         end
 
         def definition_count(owner, name)
-          @scope.discovered_deferred_ranges.sum do |_path, rows|
-            rows.count { |row| row[2] == name && row[3] == :instance && row[4] == owner }
+          count = 0
+          @scope.discovered_deferred_ranges.each_value do |rows|
+            count += rows.count { |row| row[2] == name && row[3] == :instance && row[4] == owner }
           end
+          count
         end
 
         # Whether `chain`'s own order stands with no second world: no order mark and no fork. `ResolutionChain#settle`
@@ -326,8 +329,10 @@ module Rigor
           return nil if loader.nil? || !loader.core_or_stdlib_class?(type.class_name)
 
           segment = node.name.to_s
+          suffix = "::#{segment}"
           project = [@scope.discovered_classes, @scope.in_source_constants]
-          return nil if project.any? { |table| table.each_key.any? { |name| name.to_s.split("::").last == segment } }
+          ends_with_segment = ->(name) { (name = name.to_s) == segment || name.end_with?(suffix) }
+          return nil if project.any? { |table| table.each_key.any?(&ends_with_segment) }
 
           type
         end

data/lib/rigor/inference/singleton_external_ahead.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # Issue #1572 — the singleton typing site's external-ahead decline. That site still answers from
+    # {Scope#singleton_def_through_ancestors}, which passes the chain's external entries over, so `extend M; extend
+    # Enumerable` typed `C.to_a` from `M#to_a` although Ruby calls `Enumerable#to_a` (`C.singleton_class.ancestors`
+    # starts `[#<Class:C>, Enumerable, M]`). The instance typing site reads `DefinerResolution`, which already
+    # declines there.
+    #
+    # {.withhold?} is true when the read must withhold (the call types `Dynamic`): the singleton chain holds no
+    # project entry that writes the name; the reader's `owner` has no project entry on it; or an external entry ahead
+    # of the later of the two may answer first, because RBS does not know it or declares the name in it (the test
+    # `DefinerResolution` applies, `ResolutionChain::Relevance.external_lacks_on?`). The later of the two, because
+    # where the chain does not stand the reader answers master's owner. An entry writes the name with its own `def`,
+    # never a copy the extends fold put on a class object (`RefinedDispatch::ClassObject.fold_copy?`, which also
+    # matches a copy by location where the two tables came from two parses of the file), so a folded `M#to_a`
+    # answers at `M`'s own position.
+    #
+    # ADR-46: the search files the class edge of the root and of every project entry ahead of the definer, and each
+    # tested external files the negative class edge on its spelling's last segment, as `DefinerResolution` does.
+    module SingletonExternalAhead
+      module_function
+
+      def withhold?(scope, class_name, method_name, owner)
+        chain = Scope::ResolutionChain.for(scope, class_name.to_s, :singleton, :methods)
+        definer = first_writer_index(scope, chain, method_name)
+        return true if definer.nil?
+
+        owner_index = chain.entries.index { |entry| !entry.external? && entry.name == owner.to_s }
+        return true if owner_index.nil?
+
+        external_ahead_may_answer?(scope, chain, method_name, [definer, owner_index].max)
+      end
+
+      def first_writer_index(scope, chain, method_name)
+        index = -1
+        chain.search(scope) do |entry|
+          index += 1
+          !entry.external? && writes_name?(scope, entry, method_name)
+        end && index
+      end
+
+      def writes_name?(scope, entry, method_name)
+        return !scope.user_def_for(entry.name, method_name).nil? unless entry.side == :singleton
+
+        !scope.singleton_def_for(entry.name, method_name).nil? &&
+          !RefinedDispatch::ClassObject.fold_copy?(scope, entry.name, method_name)
+      end
+
+      def external_ahead_may_answer?(scope, chain, method_name, stop)
+        recording = Analysis::DependencyRecorder.active?
+        chain.entries.first(stop).any? do |entry|
+          next false unless entry.external?
+
+          Analysis::DependencyRecorder.read_missing(:class, entry.raw.to_s.split("::").last) if recording
+          !Scope::ResolutionChain::Relevance.external_lacks_on?(scope, entry.candidates, entry.side, method_name)
+        end
+      end
+
+      private_class_method :first_writer_index, :writes_name?, :external_ahead_may_answer?
+    end
+  end
+end

data/lib/rigor/inference/singleton_hook_decline.rb

@@ -109,6 +109,13 @@ module Rigor
         nesting&.first
       end
 
+      # Issue #1722 — the hook-capable test for one chain entry, asked by `call.undefined-method` of a project module
+      # mixed into a core class: a module whose `self.included(base)` hook writes `base.class_eval { def x }` gives
+      # the includer methods no table records.
+      def entry_hook_capable?(scope, entry, flavor = :methods)
+        Context.new(scope, flavor).capable?(entry)
+      end
+
       def tested_levels(chain, from, bound)
         starts = chain.level_starts
         size = chain.entries.size