rigortype 0.4.4 → 0.4.6

data/lib/rigor/inference/self_call_ivar_writes.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../analysis/dependency_recorder"
 require_relative "../source/node_children"
 require_relative "../source/parameter_envelope"
 require_relative "../type"
@@ -139,10 +140,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)
@@ -185,7 +187,16 @@ module Rigor
 
         # Whether a `refine` block anywhere in the project defines `name`, on any class: a `using` in effect where the
         # read code sits may route the call to it (`refine Kernel do def warn …`), whatever the receiver.
+        #
+        # Issue #2163 — the answer reads every file's refinements whole, and a refined class off the chain (`Kernel`,
+        # `IO`, `String`) is no `mark:` the chain read files, so it records `refinement:<name>` and `refinement:*`
+        # whichever way it answers, as `InEffectRefinements` consumers do: a file that starts or stops refining the
+        # name re-checks the reader.
         def refined?(name)
+          if Analysis::DependencyRecorder.active?
+            Analysis::DependencyRecorder.read_name(:refinement, name)
+            Analysis::DependencyRecorder.read_name(:refinement, Scope::DiscoveryIndex::REFINEMENT_WILDCARD)
+          end
           @scope.discovered_refinements.any? { |_refined, methods| methods.key?(name) }
         end
 
@@ -229,7 +240,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
@@ -239,12 +250,11 @@ module Rigor
         # one file, with one `def` of the name there (a reopening or a `class_eval` body in the same file is a second
         # one), and no `define_method`, `attr_*` or alias of it, nor a rewrite no literal names (`T.define_method`,
         # `T.send(:define_method, …)`, `T.class_eval` with a computed name), nor a definition the walk could not prove
-        # runs (a possible or contested one, as `DefinerResolution` reads them). The class edge files every declaring
-        # file.
+        # runs (a possible or contested one, as `DefinerResolution` reads them). `Scope#parameter_envelopes_of` files
+        # the class edge to every declaring file and, issue #2137, the `mark:` edge for a file that only marks it.
         def single_definition(owner, name)
-          Scope::ResolutionChain.record_class(@scope, owner) if Analysis::DependencyRecorder.active?
+          bucket = @scope.parameter_envelopes_of(owner)
           unprovable! if possible_definition?(owner, name)
-          bucket = @scope.discovered_parameter_envelopes[owner] || {}
           unprovable! if bucket[[:instance, name]] == Source::ParameterEnvelope::OPAQUE
           unprovable! if (@scope.discovered_class_sources[owner]&.size || 0) > 1
           unprovable! if definition_count(owner, name) > 1
@@ -258,9 +268,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`
@@ -276,9 +288,12 @@ module Rigor
         end
 
         # Whether the project rewrites `class_name`'s method table beyond the names it spells, or refines it.
+        #
+        # Issue #2137 — read through `Scope#parameter_envelopes_of`, which files the `mark:` edge: a `refine` of the
+        # class from a file whose declared classes do not change fires no class key, and adding or removing it must
+        # re-check the reader.
         def rewritten?(class_name)
-          bucket = @scope.discovered_parameter_envelopes[class_name]
-          !bucket.nil? && Scope::DiscoveryIndex.rewritten_surface?(bucket)
+          Scope::DiscoveryIndex.rewritten_surface?(@scope.parameter_envelopes_of(class_name))
         end
 
         # The first project class or module on `class_name`'s settled instance chain that defines `name`, stopping
@@ -326,8 +341,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