rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/recursion_rebinding.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../source/node_walker"
+
+module Rigor
+  module Inference
+    # Which of a def's parameters its own recursion rebinds (issue #3115). The bot-collapse retry of
+    # `ExpressionTyper#fixpoint_user_method_return` types the body once for every call the recursion makes, and a
+    # recursive call binds a parameter to whatever it passes: `tog(n: n - 1, f: !f)` gives `f` a value the
+    # outer call never held. A parameter is KEPT only when every call to the def's own name inside the body
+    # passes it the same parameter read unchanged (`cfg(n - 1, mode)` keeps `mode`), and the body never
+    # assigns it; every other parameter is rebound, and the retry binds it `Dynamic[top]`.
+    #
+    # The test is syntactic and reads only the def. A call counts by its method name alone, whatever its
+    # receiver (`child.depth(n + 1)` re-enters the same recursion guard), so a same-named method of another
+    # class is read as a recursive call too, which only rebinds more. The caller supplies the def's other
+    # names (`alias`), since the def does not carry them. A call to ANOTHER method that recurses back (mutual
+    # recursion) is not followed: its parameters are judged by the def's own calls alone.
+    #
+    # Two shapes the test cannot read rebind more instead. A body that calls a method by a computed name
+    # ({REFLECTIVE_CALLS}) may recurse with any arguments, so every parameter is rebound ({ALL}). A name a
+    # block or lambda in the body declares (a parameter, a block-local, `it`) is rebound, because a read of
+    # it inside that block is the block's variable, not the parameter.
+    module RecursionRebinding
+      module_function
+
+      LOCAL_WRITE_NODES = Set[
+        Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode, Prism::LocalVariableTargetNode
+      ].freeze
+      private_constant :LOCAL_WRITE_NODES
+
+      # The calls that reach a method by a name the scan cannot read.
+      REFLECTIVE_CALLS = Set[:send, :__send__, :public_send, :method, :instance_method, :define_method].freeze
+      private_constant :REFLECTIVE_CALLS
+
+      # {.rebound_parameters}'s answer when every parameter is rebound.
+      ALL = :all
+
+      # The names the body's recursive calls, its blocks or its own assignments rebind, as a Set, or {ALL}. The
+      # Set may hold a name that is no parameter (any assigned local); the caller looks up parameters only.
+      # `names` is every name the def answers to: its own and its aliases.
+      def rebound_parameters(def_node, names = Set[def_node.name])
+        params = def_node.parameters
+        return Set.new unless params.is_a?(Prism::ParametersNode)
+
+        rebound = Set.new
+        catch(ALL) { collect(def_node.body, names, params, rebound) } == ALL ? ALL : rebound
+      end
+
+      # Every method name the body calls, for the caller to ask which of them are this def's aliases.
+      def called_names(node, names = Set.new)
+        return names if node.nil?
+
+        names << node.name if node.is_a?(Prism::CallNode)
+        node.rigor_each_child { |child| called_names(child, names) }
+        names
+      end
+
+      def collect(node, names, params, rebound)
+        return if node.nil?
+
+        case node
+        when *LOCAL_WRITE_NODES then rebound << node.name
+        when Prism::BlockNode, Prism::LambdaNode then note_block(node, rebound)
+        when Prism::CallNode
+          throw ALL, ALL if REFLECTIVE_CALLS.include?(node.name)
+
+          note_call(node, params, rebound) if names.include?(node.name)
+        end
+        node.rigor_each_child { |child| collect(child, names, params, rebound) }
+      end
+
+      # A block's `locals` are its parameters, its block-locals and the locals it first assigns; `it` is not
+      # among them.
+      def note_block(block, rebound)
+        rebound.merge(block.locals)
+        rebound << :it if block.parameters.is_a?(Prism::ItParametersNode)
+      end
+
+      def note_call(call, params, rebound)
+        args = call.arguments&.arguments || []
+        keywords = args.last if args.last.is_a?(Prism::KeywordHashNode)
+        positional = keywords ? args[0...-1] : args
+        forwarding = args.any?(Prism::ForwardingArgumentsNode)
+        note_positionals(params, positional, rebound)
+        note_keywords(params, keywords, forwarding, rebound)
+      end
+
+      # Positionals correspond by index up to the first `*splat` (or `...`), which may reach every slot from
+      # its own on. The rest parameter is kept only by `*rest` in its own place as the last positional.
+      def note_positionals(params, positional, rebound)
+        slots = params.requireds + params.optionals
+        cut = positional.index { |arg| arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::ForwardingArgumentsNode) }
+        cut ||= positional.size
+        slots.each_with_index do |param, index|
+          next if param.is_a?(Prism::MultiTargetNode)
+
+          rebound << param.name unless index < cut && reads?(positional[index], param.name)
+        end
+        note_rest(params.rest, positional[slots.size..] || [], cut >= slots.size, rebound)
+      end
+
+      def note_rest(rest, tail, aligned, rebound)
+        return unless rest.is_a?(Prism::RestParameterNode) && rest.name
+
+        splat = tail.first
+        kept = aligned && tail.size == 1 && splat.is_a?(Prism::SplatNode) && reads?(splat.expression, rest.name)
+        rebound << rest.name unless kept
+      end
+
+      # Keywords correspond by name. A keyword the call omits falls back to its default, so it is rebound. A
+      # `**splat` other than the def's own `**rest`, a non-Symbol key or `...` may carry any keyword, so each of
+      # them rebinds every keyword. `**rest` is kept by `**rest` alone, with no key beside it that it would collect.
+      def note_keywords(params, keywords, forwarding, rebound)
+        names = params.keywords.map { |param| param.name.to_s.delete_suffix(":").to_sym }
+        rest_name = keyword_rest_name(params)
+        passed, splats, opaque = keyword_entries(keywords)
+        opaque ||= forwarding || splats.any? { |value| !reads?(value, rest_name) }
+        return rebound.merge(names, [rest_name].compact) if opaque
+
+        names.each { |name| rebound << name unless reads?(passed[name], name) }
+        rebound << rest_name if rest_name && !(splats.size == 1 && (passed.keys - names).empty?)
+      end
+
+      def keyword_rest_name(params)
+        rest = params.keyword_rest
+        rest.name if rest.is_a?(Prism::KeywordRestParameterNode)
+      end
+
+      # The call's keyword hash as `[{ name => value node }, [**splat value nodes], opaque]`, `opaque` when
+      # a key is not a plain Symbol.
+      def keyword_entries(keywords)
+        passed = {}
+        splats = []
+        opaque = false
+        (keywords&.elements || []).each do |element|
+          if element.is_a?(Prism::AssocSplatNode)
+            splats << element.value
+          elsif element.key.is_a?(Prism::SymbolNode) && element.key.unescaped
+            passed[element.key.unescaped.to_sym] = element.value
+          else
+            opaque = true
+          end
+        end
+        [passed, splats, opaque]
+      end
+
+      # Whether `node` is a bare read of the local `name` (`n`, or the `n:` shorthand's implicit read).
+      def reads?(node, name)
+        node = node.value if node.is_a?(Prism::ImplicitNode)
+        !name.nil? && node.is_a?(Prism::LocalVariableReadNode) && node.name == name
+      end
+    end
+  end
+end

data/lib/rigor/inference/refined_dispatch/constructed_class.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
+
 module Rigor
   module Inference
     module RefinedDispatch
@@ -16,9 +19,16 @@ module Rigor
       # the name itself, and no constant write of it. Any other shape answers false, as does a class a
       # `K = Class.new(...)` write names.
       module ConstructedClass
-        MEMO_KEY = :__rigor_constructed_class__
+        # ADR-129 WD1 — a run-scoped Memo keyed on the run-generation token and the environment, whose tables every
+        # answer reads and which are fixed for a run.
+        MEMO = TypingState.memo(
+          :constructed_class,
+          run_scoped: true,
+          audit: ["constructed class verdict", "constructed class segments", "constructed class names"],
+          reason: "verdicts keyed on the run-generation token and environment identities"
+        )
         EMPTY = [].freeze
-        private_constant :MEMO_KEY, :EMPTY
+        private_constant :MEMO, :EMPTY
 
         module_function
 
@@ -34,9 +44,19 @@ module Rigor
           return false if named.empty?
 
           by_class = (table[:verdicts][class_name] ||= {})
-          return by_class[named] if by_class.key?(named)
+          if by_class.key?(named)
+            return MemoAudit.check("constructed class verdict", by_class[named], class_name, named) do
+              apart_verdict(scope, named, class_name, memo(scope))
+            end
+          end
+
+          by_class[named] = MemoAudit.key_audit("constructed class verdict") do
+            apart_verdict(scope, named, class_name, table)
+          end
+        end
 
-          by_class[named] = named.all? { |constant| core_class_apart?(scope, constant, class_name.to_s, table) }
+        def apart_verdict(scope, named, class_name, table)
+          named.all? { |constant| core_class_apart?(scope, constant, class_name.to_s, table) }
         end
 
         def core_class_apart?(scope, constant, class_name, table)
@@ -66,7 +86,18 @@ module Rigor
 
         # The last segment of every class or module the project declares, reopenings included.
         def declared_segments(scope, table)
-          table[:segments] ||= declared_names(scope).each_key.to_set { |key| key.to_s.split("::").last }.freeze
+          segments = table[:segments]
+          if segments.nil?
+            return table[:segments] = MemoAudit.key_audit("constructed class segments") do
+              compute_declared_segments(scope)
+            end
+          end
+
+          MemoAudit.check("constructed class segments", segments, :segments) { compute_declared_segments(scope) }
+        end
+
+        def compute_declared_segments(scope)
+          declared_names(scope).each_key.to_set { |key| key.to_s.split("::").last }.freeze
         end
 
         # The constants `name`'s superclass expression names, or an empty Array; memoised per envelope bucket,
@@ -76,15 +107,18 @@ module Rigor
           return EMPTY if bucket.nil?
 
           names = table[:names]
-          return names[bucket] if names.key?(bucket)
-
-          names[bucket] =
-            if bucket.key?(Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK)
-              EMPTY
-            else
-              kind = Scope::DiscoveryIndex::ENVELOPE_CONSTRUCTED_KIND
-              bucket.each_key.filter_map { |key| key[1] if key.is_a?(Array) && key[0] == kind }.freeze
-            end
+          if names.key?(bucket)
+            return MemoAudit.check("constructed class names", names[bucket], name) { bucket_constructed_names(bucket) }
+          end
+
+          names[bucket] = MemoAudit.key_audit("constructed class names") { bucket_constructed_names(bucket) }
+        end
+
+        def bucket_constructed_names(bucket)
+          return EMPTY if bucket.key?(Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK)
+
+          kind = Scope::DiscoveryIndex::ENVELOPE_CONSTRUCTED_KIND
+          bucket.each_key.filter_map { |key| key[1] if key.is_a?(Array) && key[0] == kind }.freeze
         end
 
         # The run-wide table of declared classes: the seeded `discovered_class_sources`, or a single-file run's
@@ -98,15 +132,21 @@ module Rigor
         # `discovered_def_nodes`, as `ExpressionTyper` falls back) and the environment: every table read here is
         # fixed for a run, so each answer is computed once a run, and a new run replaces the slot.
         def memo(scope)
-          slot = Thread.current[MEMO_KEY]
+          return new_table if MemoAudit.enabled? && MemoAudit.suspended?
+
+          state = TypingState.current
+          slot = state[MEMO]
           generation = scope.run_generation || scope.discovered_def_nodes
           environment = scope.environment
           unless slot && slot[0].equal?(generation) && slot[1].equal?(environment)
-            slot = [generation, environment, { names: {}.compare_by_identity, verdicts: {} }]
-            Thread.current[MEMO_KEY] = slot
+            slot = [generation, environment, new_table]
+            state[MEMO] = slot
           end
           slot[2]
         end
+
+        # Empty tables: a new slot's, and a throwaway set while an audit recomputation bypasses the memo.
+        def new_table = { names: {}.compare_by_identity, verdicts: {} }
       end
     end
   end

data/lib/rigor/inference/refined_dispatch/own_method.rb

@@ -2,6 +2,8 @@
 
 require_relative "../builtins/cruby_definers"
 require_relative "constructed_class"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
 
 module Rigor
   module Inference
@@ -306,30 +308,54 @@ module Rigor
 
         def unknown_superclass_classes(scope, class_name)
           Analysis::DependencyRecorder.read_name(:subclass_of, "*") if Analysis::DependencyRecorder.active?
-          table = subclass_memo(scope)
-          all = table[:unknown] ||= begin
-            mark = Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK
-            computed = scope.discovered_superclasses.filter_map { |child, parent| child if parent.nil? }
-            meta = scope.discovered_parameter_envelopes.filter_map { |name, bucket| name if bucket.key?(mark) }
-            (computed + meta).uniq.freeze
-          end
+          all = all_unknown_superclass_classes(scope)
           name = class_name.to_s
           all.include?(name) ? all - [name] : all
         end
 
-        SUBCLASS_MEMO_KEY = :__rigor_own_method_subclasses__
-        private_constant :SUBCLASS_MEMO_KEY
+        def all_unknown_superclass_classes(scope)
+          table = subclass_memo(scope)
+          stored = table[:unknown]
+          if stored.nil?
+            return table[:unknown] = MemoAudit.key_audit("own method unknown superclasses") do
+              compute_unknown_superclass_classes(scope)
+            end
+          end
+
+          MemoAudit.check("own method unknown superclasses", stored, :unknown) do
+            compute_unknown_superclass_classes(scope)
+          end
+        end
+
+        def compute_unknown_superclass_classes(scope)
+          mark = Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK
+          computed = scope.discovered_superclasses.filter_map { |child, parent| child if parent.nil? }
+          meta = scope.discovered_parameter_envelopes.filter_map { |name, bucket| name if bucket.key?(mark) }
+          (computed + meta).uniq.freeze
+        end
+
+        # ADR-129 WD1 — a run-scoped Memo keyed on the identities of the discovery index and environment, the only
+        # inputs of the buckets it holds.
+        SUBCLASS_MEMO = TypingState.memo(
+          :own_method_subclasses,
+          run_scoped: true, audit: ["own method unknown superclasses", "own method children"],
+          reason: "subclass buckets keyed on the discovery index and environment identities"
+        )
+        private_constant :SUBCLASS_MEMO
 
         # One thread-local slot keyed on the scope's discovery index (a frozen `Data`) and environment, the only
         # inputs `children_by_parent` and the unknown-superclass list read; neither files a dependency edge
         # (`each_subclass` files its own `subclass_of:` edges on every call), so a hit drops none.
         def subclass_memo(scope)
-          slot = Thread.current[SUBCLASS_MEMO_KEY]
+          return {} if MemoAudit.enabled? && MemoAudit.suspended?
+
+          state = TypingState.current
+          slot = state[SUBCLASS_MEMO]
           discovery = scope.discovery
           environment = scope.environment
           unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
             slot = [discovery, environment, {}]
-            Thread.current[SUBCLASS_MEMO_KEY] = slot
+            state[SUBCLASS_MEMO] = slot
           end
           slot[2]
         end
@@ -341,11 +367,20 @@ module Rigor
         end
 
         def children_by_parent(scope)
-          subclass_memo(scope)[:children] ||=
-            scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
-              parent = scope.ancestor_name_candidates(child, raw_parent).find { |name| known_class?(scope, name) }
-              (children[parent] ||= []) << child if parent
-            end.each_value(&:freeze).freeze
+          table = subclass_memo(scope)
+          stored = table[:children]
+          if stored.nil?
+            return table[:children] = MemoAudit.key_audit("own method children") { compute_children_by_parent(scope) }
+          end
+
+          MemoAudit.check("own method children", stored, :children) { compute_children_by_parent(scope) }
+        end
+
+        def compute_children_by_parent(scope)
+          scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
+            parent = scope.ancestor_name_candidates(child, raw_parent).find { |name| known_class?(scope, name) }
+            (children[parent] ||= []) << child if parent
+          end.each_value(&:freeze).freeze
         end
 
         def known_class?(scope, name)

data/lib/rigor/inference/refined_dispatch.rb

@@ -126,6 +126,19 @@ module Rigor
         out
       end
 
+      # ADR-121 WD7 — a names-wildcard row counts as a refinement of every name. True when a row `list` puts in
+      # effect names `method_name` (or the wildcard) for ANY refined class — which class the row refines is not
+      # decided here — or `list` carries {InEffectRefinements::UNKNOWN} and any row names it. {ExpressionTyper}
+      # asks it for a `&:name` block, whose receiver is not known; {SelfPreservingBlock} for the yielding method
+      # (issue #2909).
+      def refined_anywhere?(scope, method_name, list)
+        refinements = scope.discovered_refinements
+        return true if list.include?(InEffectRefinements::UNKNOWN) &&
+                       refinements.any? { |_refined, methods| methods.key?(method_name) || methods.key?(wildcard) }
+
+        !targets(refinements, method_name, list).nil? || !targets(refinements, wildcard, list).nil?
+      end
+
       # The refinement table records every name a `refine` argument's spelling can denote (`refine String` inside
       # `module M` records `M::String` and `String`), which only withholds a check. To type, a key must be the class
       # Ruby's lexical lookup resolves: one the project or RBS knows, with no longer spelling of the same last segment

data/lib/rigor/inference/reflective_ivar_write.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../type"
+require_relative "../typing_state"
 
 module Rigor
   module Inference
@@ -26,8 +27,13 @@ module Rigor
       IVAR_NAME = /\A@[A-Za-z_]\w*\z/
       private_constant :IVAR_NAME
 
-      REPEATING_KEY = :__rigor_reflective_ivar_write_repeating__
-      private_constant :REPEATING_KEY
+      # ADR-129 WD1 — a Frame: the depth is installed for a region and restored on the way out.
+      REPEATING = TypingState.frame(
+        :reflective_ivar_write_repeating,
+        reason: "the repeat depth of `for` bodies and loop predicates, installed per region",
+        witness: "spec/fixtures/typing_state_witnesses/reflective_ivar_write_repeating.rb"
+      )
+      private_constant :REPEATING
 
       module_function
 
@@ -69,18 +75,20 @@ module Rigor
       # rebind fixpoint, and a predicate runs before every iteration but is walked once, so a literal-name write there
       # must not replace the binding with one pass's value ({.apply}). A `while` / `until` body does not enter it: its
       # fixpoint widens the ivar (issue #1930).
-      def in_repeating_body
-        depth = Thread.current[REPEATING_KEY] || 0
-        Thread.current[REPEATING_KEY] = depth + 1
-        begin
-          yield
-        ensure
-          Thread.current[REPEATING_KEY] = depth
-        end
+      def in_repeating_body(&)
+        state = TypingState.current
+        state.with(REPEATING, (state[REPEATING] || 0) + 1, &)
+      end
+
+      # Runs the block at repeat depth zero, restoring the depth on exit. A user-method body re-typed for its return
+      # starts from its own scope and reads its own write, so a caller's `for` body does not repeat it
+      # ({ExpressionTyper.with_call_site_frame}).
+      def outside_repeating_body(&)
+        TypingState.current.with(REPEATING, 0, &)
       end
 
       def repeating_body?
-        (Thread.current[REPEATING_KEY] || 0).positive?
+        (TypingState.current[REPEATING] || 0).positive?
       end
 
       # `scope` after `node` runs. A literal name binds that ivar to the value's type (yielded), as `@n = v` does.