rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/self_call_ivar_writes.rb

@@ -9,7 +9,8 @@ require_relative "../type"
 require_relative "guard_rebinding"
 require_relative "project_method_ownership"
 require_relative "refined_dispatch/own_method"
-require_relative "../run_scoped_slots"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -116,19 +117,38 @@ module Rigor
         nil
       end
 
-      DEFINITION_COUNTS_KEY = RunScopedSlots.register(:__rigor_self_call_ivar_writes_definition_counts__)
-      private_constant :DEFINITION_COUNTS_KEY
+      # ADR-129 WD1 — a run-scoped Memo: the `[deferred_ranges, counts]` pair is one table and the counts computed
+      # from it alone, so the counts are a function of the table identity the pair is keyed on.
+      DEFINITION_COUNTS = TypingState.memo(
+        :self_call_ivar_writes_definition_counts,
+        run_scoped: true, audit: "self-call ivar definition counts",
+        reason: "the instance-def counts of one deferred-ranges table; keyed on its identity"
+      )
+      private_constant :DEFINITION_COUNTS
 
       # `{[owner, name] => the number of instance `def` rows of name the project records for owner}`, over every
       # file of `deferred_ranges` (a `discovered_deferred_ranges` table). Built once per table and kept in ONE
       # thread slot keyed by the table's identity (#2300): the table is never written in place, a file whose rows
       # equal the seed's keeps the seed's table, and a scan of every file's rows per query was the cost once the
       # table held the whole project. The slot holds one table and its counts, the next table replaces them, and the
-      # run that filled it releases it when it ends ({RunScopedSlots}, #2399).
+      # run that filled it releases it when it ends (run-scoped, #2399).
       def definition_counts(deferred_ranges)
-        slot = Thread.current[DEFINITION_COUNTS_KEY]
-        return slot[1] if slot && slot[0].equal?(deferred_ranges)
+        return count_definitions(deferred_ranges) if MemoAudit.enabled? && MemoAudit.suspended?
 
+        state = TypingState.current
+        slot = state[DEFINITION_COUNTS]
+        if slot && slot[0].equal?(deferred_ranges)
+          return MemoAudit.check("self-call ivar definition counts", slot[1], deferred_ranges.size) do
+            count_definitions(deferred_ranges)
+          end
+        end
+
+        counts = MemoAudit.key_audit("self-call ivar definition counts") { count_definitions(deferred_ranges) }
+        state[DEFINITION_COUNTS] = [deferred_ranges, counts]
+        counts
+      end
+
+      def count_definitions(deferred_ranges)
         counts = {}
         deferred_ranges.each_value do |rows|
           rows.each do |row|
@@ -138,7 +158,6 @@ module Rigor
             counts[key] = counts.fetch(key, 0) + 1
           end
         end
-        Thread.current[DEFINITION_COUNTS_KEY] = [deferred_ranges, counts]
         counts
       end
 

data/lib/rigor/inference/self_preserving_block.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "closure_escape_analyzer"
+require_relative "project_method_ownership"
+require_relative "refined_dispatch"
+
+module Rigor
+  module Inference
+    # Issue #2861 — whether a block-carrying call provably runs its literal block under the CALLER's `self`, so the
+    # block body is no more opaque than the scope around it (`Scope#entering_self_preserving_block`).
+    #
+    # Issue #316 enters every block with `self` unmodelled, because a DSL call (`RSpec.describe`, `Class.new`, a
+    # project `def run(&b) = instance_exec(&b)`) may run the block on another object, and the call cannot be told
+    # apart from `Array#each` without knowing the callee. Here the callee is known: the explicit receiver's type and
+    # method are one {ClosureEscapeAnalyzer} classifies as `:non_escaping` — a catalogued core iterator, `tap` /
+    # `then`, or a project class's inherited `Enumerable` method — each of which `yield`s, which runs the block
+    # with its own `self`. The project must not define the method anywhere the receiver looks it up
+    # ({ProjectMethodOwnership.defines?}): a project reopening of `Array#each` could `instance_exec` the block.
+    # A `def` inside `refine X do … end` is no such answer, so where the call site's in-effect refinements may
+    # define the name the call declines too (issue #2909) — a refined `Integer#times` or `Object#tap` could
+    # `instance_exec` the block just the same.
+    #
+    # The project must not define it on `Object`, `Kernel` or another owner every receiver reaches either
+    # ({.universally_defined?}). A receiverless call is the DSL shape and never answers true, nor does a receiver Rigor
+    # cannot see. A `self.` receiver is read like any other explicit one, through its type.
+    module SelfPreservingBlock
+      module_function
+
+      # `classification` is the receiver's {ClosureEscapeAnalyzer.classify} answer when the caller already holds it.
+      def call?(call_node, receiver_type, scope, classification: nil)
+        return false unless call_node.is_a?(Prism::CallNode) && call_node.block.is_a?(Prism::BlockNode)
+
+        return false if call_node.receiver.nil? || receiver_type.nil?
+
+        method_name = call_node.name
+        classification ||= ClosureEscapeAnalyzer.classify(receiver_type: receiver_type, method_name: method_name,
+                                                          scope: scope)
+        return false unless classification == :non_escaping
+
+        project_shadow_free?(call_node, receiver_type, method_name, scope)
+      rescue StandardError
+        false
+      end
+
+      # The project-side half of {.call?}: nothing the project defines — a plain `def` on a lookup target or a
+      # {UNIVERSAL_OWNERS} entry, nor a refinement in effect at the call site — may answer the yielding method
+      # instead of the catalogued non-escaping one.
+      def project_shadow_free?(call_node, receiver_type, method_name, scope)
+        targets = ProjectMethodOwnership.targets(receiver_type)
+        return false if targets.nil? || targets.empty?
+        return false if universally_defined?(method_name, scope)
+
+        targets.none? { |class_name, kind| ProjectMethodOwnership.defines?(class_name, method_name, kind, scope) } &&
+          !refined_in_effect?(call_node, method_name, scope)
+      end
+
+      # The classes every receiver's lookup reaches: an instance of any class is an `Object` (a class object is also
+      # a `Module` and a `Class`), so a project method of the name on one of them, or on `Kernel`, which
+      # {ProjectMethodOwnership.defines?} reaches through `Object`'s ancestry, may be the one the call runs, whatever
+      # class the receiver names. `ClosureEscapeAnalyzer` answers `tap` / `then` / `yield_self` for every class
+      # without asking who defines them.
+      UNIVERSAL_OWNERS = %w[Object Module Class].freeze
+      private_constant :UNIVERSAL_OWNERS
+
+      # Whether the project defines `method_name` on a {UNIVERSAL_OWNERS} entry. A top-level `def` of the name is
+      # private, so an explicit-receiver call raises NoMethodError before any block runs, and is not counted.
+      def universally_defined?(method_name, scope)
+        UNIVERSAL_OWNERS.any? { |owner| ProjectMethodOwnership.defines?(owner, method_name, :instance, scope) }
+      end
+
+      # Issue #2909 — whether a refinement in effect at `call_node` may define `method_name`. The refined-class
+      # walk is not consulted: any in-effect row for the name declines, the direction ADR-5 prefers, and it covers
+      # `refine Object` / `refine Kernel` without a universal-owner path of its own. An empty list — no `using`
+      # reaches the node — is the common case and costs the one lookup. The answer reads the refinement table by
+      # method name, so `refinement:<name>` is recorded as {ExpressionTyper}'s refined dispatch records it.
+      def refined_in_effect?(call_node, method_name, scope)
+        list = scope.in_effect_refinements(call_node)
+        return false if list.empty?
+
+        InEffectRefinements.record_refinement_names(method_name)
+        RefinedDispatch.refined_anywhere?(scope, method_name, list)
+      end
+    end
+  end
+end

data/lib/rigor/inference/singleton_hook_decline.rb

@@ -37,7 +37,8 @@ module Rigor
     # Known remainders, pinned in `spec/integration/definer_resolution_witness_spec.rb`: `class << self; prepend
     # P` is recorded as an `extend` (the chain places `P` after the singleton, so an own `def self.x` is trusted
     # against it); a concern is capable for every name; an own `def self.x` is trusted against its own level's
-    # U2 hooks and same-class redefinitions; a `class Class; def inherited` monkeypatch is unseen; and a
+    # U2 hooks and same-class redefinitions, except a concern block's `def self.x` of the same name (#3005, which
+    # the read tests); a `class Class; def inherited` monkeypatch is unseen; and a
     # superclass that only `extend`s adds two forks, so every read on its subclasses declines.
     module SingletonHookDecline
       WILDCARD = "*"
@@ -65,7 +66,8 @@ module Rigor
         entry = chain.entries[index]
         # A singleton project entry on a singleton chain is always a level's class entry.
         own = !entry.external? && entry.side == :singleton && def_head(scope, entry.name, method_name) == entry.name
-        own ? index : index + 1
+        # Issue #3005 — an own `def self.x` that a concern block's `def self.x` on its level may replace is tested.
+        own && !chain.hook_block_rival?(scope, index, method_name) ? index : index + 1
       end
 
       # What a class entry's answer is when its `def` was written in another module's body: `:copy` when that
@@ -92,14 +94,22 @@ module Rigor
       # Whether the class's singleton `def` is the very node `head`'s instance table holds, the one the fold
       # copied: a receiverless `def`. A `def C.x` or `class << C; def x; end` written inside `head`'s body has the
       # same nesting head and is the class's own, not a copy. (The walk records a `def C.x` written in `module X`
-      # as `X#x` too, so identity alone does not tell it from a copy; its receiver does.)
+      # as `X#x` too, so identity alone does not tell it from a copy; its receiver does.) Issue #3155 — the walk no
+      # longer files that `def C.x` anywhere, so the copy is all the table holds; the definer's mark on the class
+      # (`ENVELOPE_OBJECT_SINGLETON_KIND`, {ScopeIndexer#record_object_singleton}) still says the class has its own.
       def copied_from?(scope, head, method_name, owner)
         node = scope.singleton_def_for(owner, method_name)
         return false if node.nil? || !node.receiver.nil?
+        return false if foreign_singleton_definer?(scope, owner, method_name)
 
         scope.user_def_for(head, method_name).equal?(node)
       end
 
+      def foreign_singleton_definer?(scope, owner, method_name)
+        key = [Scope::DiscoveryIndex::ENVELOPE_OBJECT_SINGLETON_KIND, method_name.to_sym]
+        scope.parameter_envelopes_of(owner).key?(key)
+      end
+
       # The innermost `Module.nesting` entry `owner`'s singleton `def` of the name was written in, or nil.
       def def_head(scope, owner, method_name)
         node = scope.singleton_def_for(owner, method_name)
@@ -170,15 +180,40 @@ module Rigor
 
         # The memoised `[verdict, edges]` of one test, its edges replayed while a recording is active.
         def verdict(kind, key)
-          verdict, edges = @memo[[kind, key]] ||= begin
+          memo_key = [kind, key]
+          entry = @memo[memo_key]
+          if entry.nil?
             edges = []
-            value = yield(edges)
-            [value ? true : false, edges.concat(own_edges(kind, key)).uniq.freeze].freeze
+            value = MemoAudit.key_audit("singleton hook verdict") { yield(edges) }
+            entry = @memo[memo_key] = [value ? true : false, edges.concat(own_edges(kind, key)).uniq.freeze].freeze
+          else
+            entry = MemoAudit.check("singleton hook verdict", entry, kind, key) { fresh_verdict(kind, key) }
           end
+          verdict, edges = entry
           replay(edges) if @recording
           verdict
         end
 
+        # ADR-129 G2 — a memoised verdict rebuilt for the audit by a new Context, whose memo is a fresh bucket's
+        # while the recomputation runs ({Scope::ResolutionChain.hook_memo}), its dependency reads withheld.
+        def fresh_verdict(kind, key)
+          Analysis::DependencyRecorder.withhold { Context.new(@scope, @flavor).verdict_entry(kind, key) }.first
+        end
+
+        protected
+
+        # The `[verdict, edges]` entry of one test, computed through {#verdict} on this Context's memo.
+        def verdict_entry(kind, key)
+          case kind
+          when :project then verdict(:project, key) { project_capable?(key) }
+          when :external then verdict(:external, key) { external_capable?(key) }
+          else instance_level_capable?(key)
+          end
+          @memo[[kind, key]]
+        end
+
+        private
+
         def own_edges(kind, key)
           return entry_edges(key) if kind == :external
           return EMPTY_EDGES if kind == :instance_level

data/lib/rigor/inference/singleton_object_constant.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../source/constant_path"
+require_relative "../source/parameter_envelope"
 
 module Rigor
   module Inference
@@ -45,18 +46,47 @@ module Rigor
         name = receiver_constant_name(call_node, receiver_type)
         return false if name.nil?
 
-        scope.discovered_method?(name, method_name, :singleton)
+        scope.discovered_method?(name, method_name, :singleton) || foreign_singleton?(scope, name, method_name)
+      end
+
+      # Issue #3016 — `def Const.x` written outside `Const`'s own body, and `Const.define_singleton_method(:x)`, record
+      # no `:singleton` row: {ScopeIndexer} files them as an opaque `[:singleton, x]` envelope on every name the
+      # constant can denote from the def site. That envelope is the evidence the method exists on the constant's
+      # object. The read records the constant's class edge, and that edge's file set holds every file writing such a
+      # def or call, so adding or removing one re-checks the call.
+      #
+      # A computed `Const.define_singleton_method(name)` may define any name, so the singleton side's open-names mark it
+      # files declines every call through the constant.
+      def foreign_singleton?(scope, name, method_name)
+        bucket = scope.parameter_envelopes_of(name)
+        bucket.key?([:singleton, method_name.to_sym]) ||
+          bucket.key?(Scope::DiscoveryIndex::ENVELOPE_OPEN_SINGLETON_NAMES_MARK)
       end
 
       # The `Prism::DefNode` for `method_name` in the constant's singleton body, or nil. The inference tier's
       # entry point.
+      #
+      # Issue #3018 — nil too when another definer of the name on the constant may replace that def: a `def Const.x`,
+      # a `Const.define_singleton_method(:x)` or a `singleton_class.class_eval` def joins an opaque envelope into the
+      # name's `[:singleton, x]` slot, and a computed `define_singleton_method` files the open-names mark. The body
+      # def's own contribution is its parameter envelope, never opaque, so a lone body def keeps its typed answer.
+      # Declined whatever the source order, since a two-file project has none.
       def def_node_for(call_node, receiver_type, method_name, scope)
         return nil if scope.nil?
 
         name = receiver_constant_name(call_node, receiver_type)
         return nil if name.nil?
 
-        scope.singleton_def_for(name, method_name)
+        def_node = scope.singleton_def_for(name, method_name)
+        return nil if def_node.nil? || replaceable?(scope, name, method_name)
+
+        def_node
+      end
+
+      def replaceable?(scope, name, method_name)
+        bucket = scope.parameter_envelopes_of(name)
+        Source::ParameterEnvelope.opaque?(bucket[[:singleton, method_name.to_sym]]) ||
+          bucket.key?(Scope::DiscoveryIndex::ENVELOPE_OPEN_SINGLETON_NAMES_MARK)
       end
     end
   end