rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/project_patched_scanner.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../typing_state"
 require_relative "project_patched_methods"
 require_relative "project_patched_definedness_guard"
 require_relative "project_patched_visibility"
@@ -45,6 +46,38 @@ module Rigor
       end
       private_constant :GuardedDef
 
+      # A `module_function` singleton copy a `def`-form produced (`module_function def x`, or a `def` under a
+      # bare `module_function`): `entry` is the copy to bind and `def_entry` the instance entry it was copied
+      # from, so {resolve_aliases} records which def the singleton binding answers — a later named
+      # `module_function :x` keeps the copy only while that def is proved unchanged (issue #3056).
+      SingletonCopy = Data.define(:entry, :def_entry) do
+        def source_path = entry.source_path
+      end
+      private_constant :SingletonCopy
+
+      # A statement the walk does not read that may rebind a method: any call other than a visibility call, a
+      # literal-named `alias_method`, or a receiverless `include` / `extend`, plus an `alias` with a computed
+      # name and an `undef`. `define_method(:x)`, `class_eval "def x"`, `send(:define_method, ...)` and
+      # `attr_reader :x` all make Ruby's next `module_function :x` copy a fresh public body, so after one
+      # {resolve_aliases} no longer assumes a copy is unchanged (issue #3056).
+      Unread = Data.define(:source_path)
+      private_constant :Unread
+
+      # The receiverless calls the walk reads as not rebinding a method of the body's own class.
+      MIXIN_CALLS = %i[include extend].freeze
+      private_constant :MIXIN_CALLS
+
+      # ADR-129 WD1 — the two per-file inputs of the walk, each a Frame {.walk_file} installs for the file's walk and
+      # restores on the way out: the `def`s on the undefined side of a definedness guard, and each `def`'s visibility.
+      # Both are frozen once built and read only by {.walk_node}'s callees.
+      #
+      # G1′: the walk is a Prism traversal that never types, so no `type_of` runs while either is installed.
+      GUARDED_DEFS = TypingState.frame(:patched_scanner_guarded_defs, reason: "installed per scanned file's walk",
+                                                                      typing_unreachable: true)
+      DEF_VISIBILITIES = TypingState.frame(:patched_scanner_def_visibilities, reason: "installed per scanned file",
+                                                                              typing_unreachable: true)
+      private_constant :GUARDED_DEFS, :DEF_VISIBILITIES
+
       module_function
 
       # @param paths — absolute paths to the pre-eval files. The runner has already
@@ -61,11 +94,13 @@ module Rigor
         paths.each { |path| scan_file(path, collected, diagnostics, buffer, census) }
         pending_mixins, collected = collected.partition { |item| item.is_a?(Mixins::Pending) }
         overrides = {}
-        entries = resolve_aliases(collected, overrides)
+        singleton_copies = Set.new
+        entries = resolve_aliases(collected, overrides, singleton_copies)
         diagnostics.concat(duplicate_declaration_diagnostics(entries))
         Result.new(
           registry: ProjectPatchedMethods.new(entries: entries, write_census: census.freeze, overrides: overrides,
-                                              mixins: Mixins.resolve(pending_mixins, entries)),
+                                              mixins: Mixins.resolve(pending_mixins, entries),
+                                              singleton_copies: singleton_copies),
           diagnostics: diagnostics
         )
       end
@@ -114,23 +149,37 @@ module Rigor
       # A {Visibility::Pending} (issue #1708) changes the visibility of the binding its name has when it runs, in the
       # file that bound it, so it is not a second declaration; a name no earlier patch binds on the class is one it
       # inherits, recorded in `overrides` ({Visibility.apply}). `module_function :x` also binds the public singleton
-      # copy.
-      def resolve_aliases(collected, overrides = {})
+      # copy: an entry {.applied} yields for a bound name, or a `[class_name, name]` pair in `singleton_copies`
+      # (issue #2108) for an inherited one, whose body the scan cannot name.
+      #
+      # `bound_defs` holds each key's def / alias-produced entry — the def identity a visibility change does not
+      # move — and `copy_sources` each singleton key's `module_function` copy source, the pair
+      # {Visibility.apply} reads to keep a repeated `module_function :x` from re-publicing a copy
+      # `private_class_method` made private (issue #3056).
+      def resolve_aliases(collected, overrides = {}, singleton_copies = Set.new)
         bound = {}
         homes = {}
+        bound_defs = {}
+        copy_sources = {}
         per_file = collected.group_by(&:source_path).values.map do |items|
           final = {}
           items.each do |item|
             if item.is_a?(Visibility::Pending)
-              next Visibility.apply(item, bound, homes, overrides) { |copy| bind(copy, bound, homes, final) }
+              next Visibility.apply(item, bound, homes, overrides, singleton_copies, bound_defs, copy_sources) do |copy|
+                bind(copy, bound, homes, final)
+              end
             end
+            next if copy_provenance_item?(item, bound, homes, final, copy_sources)
 
             entry = item.is_a?(PendingAlias) ? alias_entry(item, bound) : item
             entry = entry.entry if entry.is_a?(GuardedDef)
             key = [entry.class_name, entry.method_name, entry.kind]
-            next if item.is_a?(GuardedDef) && bound.key?(key)
+            # A guarded def dropped here may still run (`method_defined?` ignores a private method), so the
+            # copy it would rebind is no longer known to be unchanged.
+            next copy_sources.delete([key[0], key[1], :singleton]) if item.is_a?(GuardedDef) && bound.key?(key)
 
             bind(entry, bound, homes, final)
+            record_binding(key, entry, bound_defs, copy_sources)
           end
           final
         end
@@ -138,6 +187,33 @@ module Rigor
       end
       private_class_method :resolve_aliases
 
+      # The bookkeeping {resolve_aliases} keeps beside `bound`: `bound_defs` holds the def / alias
+      # entry `key` binds — the def identity a visibility change does not move, which
+      # {Visibility.apply}'s `module_function` re-copy check compares — and a singleton-side binding
+      # clears the copy provenance, since a `def self.x` between two `module_function :x` calls makes
+      # the next copy fresh (issue #3056).
+      def record_binding(key, entry, bound_defs, copy_sources)
+        bound_defs[key] = entry
+        copy_sources.delete([entry.class_name, entry.method_name, :singleton]) if entry.kind == :singleton
+      end
+      private_class_method :record_binding
+
+      # The two items that only move the `module_function` copy provenance {Visibility.apply}'s re-copy
+      # check compares (issue #3056), handled here and answered true: a {SingletonCopy} binds the copy and
+      # records which instance def entry it was made from, and an {Unread} statement forgets every record,
+      # since it may have rebound any name.
+      def copy_provenance_item?(item, bound, homes, final, copy_sources)
+        case item
+        when SingletonCopy
+          bind(item.entry, bound, homes, final)
+          copy_sources[[item.entry.class_name, item.entry.method_name, :singleton]] = item.def_entry
+        when Unread then copy_sources.clear
+        else return false
+        end
+        true
+      end
+      private_class_method :copy_provenance_item?
+
       def bind(entry, bound, homes, final)
         key = [entry.class_name, entry.method_name, entry.kind]
         bound[key] = entry
@@ -184,18 +260,16 @@ module Rigor
                    "#{e.class}: #{e.message}. Pre-evaluation skipped for this file; " \
                    "the rest of the run proceeds."
         )
-      ensure
-        Thread.current[:rigor_guarded_defs] = nil
-        Thread.current[:rigor_def_visibilities] = nil
       end
       private_class_method :scan_file
 
       # Walks one parsed file with its definedness guards and `def` visibilities (issue #1708) in reach of
       # {record_def_node}.
       def walk_file(root, path, entries)
-        Thread.current[:rigor_guarded_defs] = DefinednessGuard.defs(root)
-        Thread.current[:rigor_def_visibilities] = Visibility.defs(root)
-        walk_node(root, [], false, path, entries)
+        TypingState.current.with_pair(GUARDED_DEFS, DefinednessGuard.defs(root).freeze,
+                                      DEF_VISIBILITIES, Visibility.defs(root).freeze) do
+          walk_node(root, [], false, path, entries)
+        end
       end
       private_class_method :walk_file
 
@@ -231,17 +305,10 @@ module Rigor
           descend_singleton_class(node, qualified_prefix, source_path, entries)
         when Prism::DefNode
           record_def_node(node, qualified_prefix, in_singleton_class, source_path, entries)
-        when Prism::AliasMethodNode
-          record_alias(node, Source::AliasNames.keyword_names(node), qualified_prefix, in_singleton_class,
-                       source_path, entries)
+        when Prism::AliasMethodNode, Prism::UndefNode
+          record_keyword(node, qualified_prefix, in_singleton_class, source_path, entries)
         when Prism::CallNode
-          record_alias(node, Source::AliasNames.alias_method_call_names(node), qualified_prefix,
-                       in_singleton_class, source_path, entries)
-          if Thread.current[:rigor_def_visibilities]&.[](node).equal?(Visibility::STATEMENT)
-            pending = Visibility.pending(node, qualified_prefix, in_singleton_class, source_path)
-            entries << pending if pending
-            entries.concat(Mixins.pending(node, qualified_prefix, in_singleton_class))
-          end
+          record_call(node, qualified_prefix, in_singleton_class, source_path, entries)
           walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
         else
           walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
@@ -249,6 +316,34 @@ module Rigor
       end
       private_class_method :walk_node
 
+      # An `alias` with literal names binds as {record_alias} reads it; a computed-name `alias` or an `undef`
+      # is {Unread}.
+      def record_keyword(node, qualified_prefix, in_singleton_class, source_path, entries)
+        names = node.is_a?(Prism::AliasMethodNode) ? Source::AliasNames.keyword_names(node) : nil
+        entries << Unread.new(source_path: source_path) if names.nil?
+        record_alias(node, names, qualified_prefix, in_singleton_class, source_path, entries)
+      end
+      private_class_method :record_keyword
+
+      def record_call(node, qualified_prefix, in_singleton_class, source_path, entries)
+        names = Source::AliasNames.alias_method_call_names(node)
+        entries << Unread.new(source_path: source_path) if names.nil? && unread_call?(node)
+        record_alias(node, names, qualified_prefix, in_singleton_class, source_path, entries)
+        return unless TypingState.current[DEF_VISIBILITIES]&.[](node).equal?(Visibility::STATEMENT)
+
+        pending = Visibility.pending(node, qualified_prefix, in_singleton_class, source_path)
+        entries << pending if pending
+        entries.concat(Mixins.pending(node, qualified_prefix, in_singleton_class))
+      end
+      private_class_method :record_call
+
+      def unread_call?(node)
+        return false if Visibility.call(node)
+
+        !(MIXIN_CALLS.include?(node.name) && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)))
+      end
+      private_class_method :unread_call?
+
       def walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
         node.rigor_each_child do |child|
           walk_node(child, qualified_prefix, in_singleton_class, source_path, entries)
@@ -288,9 +383,9 @@ module Rigor
           source_path: source_path, source_line: line,
           return_type: return_type
         )
-        entry, *copies = Visibility.applied(entry, Thread.current[:rigor_def_visibilities]&.[](node) || :public)
-        entries << (Thread.current[:rigor_guarded_defs]&.key?(node) ? GuardedDef.new(entry: entry) : entry)
-        entries.concat(copies)
+        entry, *copies = Visibility.applied(entry, TypingState.current[DEF_VISIBILITIES]&.[](node) || :public)
+        entries << (TypingState.current[GUARDED_DEFS]&.key?(node) ? GuardedDef.new(entry: entry) : entry)
+        entries.concat(copies.map { |copy| SingletonCopy.new(entry: copy, def_entry: entry) })
       end
       private_class_method :record_def_node
 

data/lib/rigor/inference/project_patched_visibility.rb

@@ -98,20 +98,56 @@ module Rigor
         # second declaration. A name the class does not bind is one it inherits (`public :kp` in `class Integer` over
         # `module Kernel; private def kp`), which Ruby copies onto the class with the new visibility: `overrides` gets
         # `key => visibility` for {ProjectPatchedMethods#lookup_through_ancestors} to apply to the body it finds farther
-        # on. Yields each copy that binds (`module_function :x`'s singleton), at the call's line, for the caller to
+        # on. `module_function :x` also binds the public singleton copy: for a name the class binds, {.applied} yields
+        # it to bind here; for an inherited one (issue #2108) `singleton_copies` records `[class_name, name]`, which
+        # {ProjectPatchedMethods#singleton_copy_entry} resolves through the owner's instance ancestors at call time
+        # (an approximation: Ruby snapshots the body when module_function runs)
+        # — the copy's body is whichever method the name reaches there, which the scan cannot name.
+        # Yields each copy that binds (`module_function :x`'s singleton), at the call's line, for the caller to
         # bind.
-        def apply(pending, bound, homes, overrides)
+        #
+        # `bound_defs` maps each bound key to the entry a `def` / `alias` last produced for it — the def
+        # identity a visibility change (`private :x`) does not move — and `copy_sources` maps a singleton key
+        # to the instance def entry its `module_function` copy was made from. Ruby re-copies the instance
+        # method onto the singleton only when that def changed since the last copy (issue #3056): a
+        # `private_class_method :x` between two `module_function :x` calls keeps the copy private, while a
+        # `def x` redefinition, or any statement the scan does not read, makes the next copy public again.
+        def apply(pending, bound, homes, overrides, singleton_copies, bound_defs, copy_sources)
           pending.names.each do |name|
             key = [pending.class_name, name, pending.kind]
             entry = bound[key]
-            next overrides[key] = pending.visibility if entry.nil?
+            if entry.nil?
+              overrides[key] = pending.visibility
+              singleton_copies << [pending.class_name, name] if pending.visibility == :module_function
+              next
+            end
 
             changed, *copies = applied(entry, pending.visibility)
+            copies = [] if unchanged_module_function_copy?(pending, key, bound_defs, copy_sources)
             bound[key] = homes[key][key] = changed
             copies.each { |copy| yield copy.with(source_path: pending.source_path, source_line: pending.source_line) }
           end
         end
 
+        # Issue #3056 — true only when `pending` is a `module_function` named call whose singleton copy is
+        # proved to answer the same instance def: the copy's recorded source is still the def / alias
+        # binding `key` has. `resolve_aliases` drops that record whenever something may have rebound the
+        # name (a singleton-side `def`, a guarded def it dropped, or any statement the walk does not read),
+        # and then Ruby's re-copy is public, the reading that refuses no call Ruby runs. `bound_defs[key]` is
+        # the def entry `key` binds — a visibility change does not move it — and `copy_sources[skey]` the
+        # instance def entry the singleton's current copy was made from; either way the source is
+        # (re)recorded for the next call.
+        def unchanged_module_function_copy?(pending, key, bound_defs, copy_sources)
+          return false unless pending.visibility == :module_function
+
+          skey = [key[0], key[1], :singleton]
+          def_entry = bound_defs[key]
+          source = copy_sources[skey]
+          copy_sources[skey] = def_entry
+          !source.nil? && source.equal?(def_entry)
+        end
+        private_class_method :unchanged_module_function_copy?
+
         # `entry` as `visibility` leaves it, then any copy that binds: `module_function` makes an instance method
         # private and binds a public singleton copy, as Ruby does.
         def applied(entry, visibility)

data/lib/rigor/inference/project_yielder.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../type"
+require_relative "block_run_count"
 
 module Rigor
   module Inference
@@ -12,10 +13,12 @@ module Rigor
     # counted as running the block once, and a `return` in the block that only a later run reaches (`each { return
     # false if (seen += 1) > 3 }`) never joined the method's return type.
     #
-    # Only the later-run `return` pass asks this (`StatementEvaluator#collect_repeated_block_returns`); the block's
-    # entry scopes and the ADR-56 write-back keep {BlockRepetition}'s rule. That pass only widens the method's
-    # return type, so the rule here errs toward "repeats". The callee repeats when its body, outside a nested `def`
-    # (a `yield` in a class body is a syntax error inside a method):
+    # Only the later-run `return` pass asks {.may_run_block_repeatedly?}
+    # (`StatementEvaluator#collect_repeated_block_returns`); the block's entry scopes and the ADR-56 write-back keep
+    # {BlockRepetition}'s rule. That pass only widens the method's return type, so the rule here errs toward
+    # "repeats". The expression-position block-value pass asks {.block_value_may_repeat?} instead, whose rule
+    # ({BlockRunCount}) errs the other way. The callee repeats when its body, outside a nested `def` (a `yield` in a
+    # class body is a syntax error inside a method):
     #
     # - holds two or more sites that run the block (`yield`, or `call` / `yield` / `===` / `[]` on the `&blk`
     #   parameter), or one inside a loop, a block or a lambda, which may run it many times; or
@@ -41,26 +44,17 @@ module Rigor
         false
       end
 
-      # Issue #2301 — whether the callee hands the block it is called with on to another call (`g(x, &)`,
-      # `g(x, &blk)`), outside a nested `def`. The block-return pass types such a forward's target `yield` as the
-      # caller's block ({ExpressionTyper#forwarded_block_return_type}), and the target may run it any number of
-      # times, so the caller's block is typed as one that may repeat. Answers false where the callee does not resolve.
-      def hands_block_on?(call_node, receiver_type, scope)
+      # Issues #2301 and #2303 — whether the callee may run the block more than once on one path, for the
+      # expression-position block-value pass ({BlockRunCount}). Answers false where the callee does not resolve.
+      def block_value_may_repeat?(call_node, receiver_type, scope)
         def_node = callee_def(call_node, receiver_type, scope)
         return false unless def_node.is_a?(Prism::DefNode) && def_node.body
 
-        hand_off_in?(def_node.body, def_node.parameters&.block&.name)
+        BlockRunCount.may_repeat?(def_node, scope)
       rescue StandardError
         false
       end
 
-      def hand_off_in?(node, block_name)
-        return false if node.is_a?(Prism::DefNode)
-        return true if node.is_a?(Prism::BlockArgumentNode) && forwards_block?(node, block_name)
-
-        node.compact_child_nodes.any? { |child| hand_off_in?(child, block_name) }
-      end
-
       # The `def` an instance call on a project class, a singleton call on one, or an implicit-self call to a
       # top-level method resolves to.
       def callee_def(call_node, receiver_type, scope)

data/lib/rigor/inference/rbs_type_translator.rb

@@ -3,6 +3,8 @@
 require "rbs"
 
 require_relative "../type"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -36,8 +38,9 @@ module Rigor
     #   `untyped`. `Type::Intersection` stays out of this path: it is the same-base refinement composite
     #   carrier, and the dispatch tiers do not accept it as a receiver.
     #
-    # Interface types still degrade to `Dynamic[Top]`; they are bound to acceptance and dispatch rules
-    # not yet implemented.
+    # Interface types degrade to `Dynamic[Top]`, except an interface in the `Rigor::Plugin` namespace, which
+    # translates to `Dynamic[Type::Interface]` (ADR-130 WD1/WD4): `untyped` to every rule, and resolvable only by a
+    # call of a member it declares (`RbsDispatch`).
     #
     # The optional `self_type:` and `instance_type:` arguments are the Rigor counterparts of RBS's
     # `self` and `instance` tokens:
@@ -78,7 +81,7 @@ module Rigor
         RBS::Types::Alias => :translate_alias,
         RBS::Types::Intersection => :translate_intersection,
         RBS::Types::Variable => :translate_variable,
-        RBS::Types::Interface => :translate_untyped
+        RBS::Types::Interface => :translate_interface
       }.freeze
       private_constant :TRANSLATORS
 
@@ -106,14 +109,12 @@ module Rigor
       # repeat with one frozen String.
       @relative_names = {}
 
-      # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion. Closed means no
-      # `self`, `instance` or type variable anywhere inside, so the caller's context cannot change the
-      # answer; at expansion depth 0 the budget cannot either. rbs compares types by value, so the memo
-      # is per distinct expansion, not per loader (a re-parsed identical alias hits), and the weak keys
-      # let an entry go with the loader whose memo held the expansion. `Rigor::Type::t` on the self-check
-      # is a 21-member union that was re-translated ~13k times, each time re-normalising the union from
-      # scratch; every repeat now shares one Union.
-      @closed_alias_translations = ObjectSpace::WeakKeyMap.new
+      # ADR-130 WD2 — the erasure baseline's flag, installed by {.with_interface_erasure}.
+      INTERFACE_ERASURE = TypingState.frame(
+        :interface_erasure, reason: "a flag installed around an erasure-baseline run (the parity harness)",
+                            witness: "spec/fixtures/typing_state_witnesses/interface_erasure.rb"
+      )
+      private_constant :INTERFACE_ERASURE
 
       class << self
         # @param self_type — substitute for `Bases::Self`.
@@ -130,6 +131,20 @@ module Rigor
           translate_in(rbs_type, Context.new(self_type, instance_type, type_vars, alias_expander, 0))
         end
 
+        # ADR-130 WD2 — the erasure baseline. Inside the block every RBS interface translates to `untyped`, as it did
+        # before ADR-130, whatever carrier the default engine has; the behavioural parity gate
+        # (`spec/integration/interface_parity_spec.rb`) runs its baseline here, so the baseline never comes from the
+        # default engine. {translate_interface} reads {interface_erasure?}, and {translate_alias} bypasses the loader's
+        # closed-alias memo under it, so a translation made in one mode is never served in the other (ADR-130 WD4). The
+        # switch lives in the calling thread's (and fiber's) `TypingState`, so a run under it is sequential: a pooled
+        # run raises (`PoolCoordinator`).
+        def with_interface_erasure(&)
+          MemoAudit.check_run_level_install(:interface_erasure)
+          TypingState.current.with(INTERFACE_ERASURE, true, &)
+        end
+
+        def interface_erasure? = TypingState.current[INTERFACE_ERASURE] == true
+
         private
 
         def translate_in(rbs_type, context)
@@ -151,6 +166,28 @@ module Rigor
           Type::Combinator.untyped
         end
 
+        # ADR-130 WD4 — the namespace whose interfaces carry the facet: `::Rigor::Plugin::_Scope` and its siblings.
+        PLUGIN_INTERFACE_PATH = %i[Rigor Plugin].freeze
+        private_constant :PLUGIN_INTERFACE_PATH
+
+        # ADR-130 WD1/WD4 — a `Rigor::Plugin` interface is `Dynamic[Interface]`; every other interface, rbs core's
+        # conversion aliases (`int`, `string`, ...) included, is `untyped` as before. Which one is a pure function of
+        # the `TypeName` (its namespace path, read without allocating), so a closed alias translates alike whichever
+        # file or worker reaches it first. Under {with_interface_erasure} every interface is `untyped`.
+        def translate_interface(rbs_type, context)
+          name = rbs_type.name
+          return Type::Combinator.untyped unless name.namespace.path == PLUGIN_INTERFACE_PATH
+          return Type::Combinator.untyped if interface_erasure?
+
+          carrier =
+            if rbs_type.args.empty?
+              Type::Interface.new(relative_name(name))
+            else
+              Type::Interface.new(relative_name(name), rbs_type.args.map { |arg| translate_in(arg, context) })
+            end
+          Type::Combinator.dynamic(carrier)
+        end
+
         def translate_nil(_rbs_type, _context)
           Type::Combinator.constant_of(nil)
         end
@@ -251,18 +288,34 @@ module Rigor
 
           expanded = expander.expand_type_alias(rbs_type)
           return Type::Combinator.untyped if expanded.nil?
+
           # A nested expansion is translated under its parent's budget, and `rigor trace` records every
-          # union merge as it happens, so neither consults the memo.
-          return translate_in(expanded, context.deeper) unless context.alias_depth.zero? && !FlowTracer.active?
+          # union merge as it happens, so neither consults the memo. Nor does the erasure baseline (ADR-130 WD4): the
+          # memo holds the default engine's translations, where a `Rigor::Plugin` interface keeps its facet.
+          memo = closed_translations_of(expander)
+          unless memo && context.alias_depth.zero? && !FlowTracer.active? && !interface_erasure?
+            return translate_in(expanded, context.deeper)
+          end
 
-          cached = @closed_alias_translations[expanded]
+          cached = memo[expanded]
           return cached if cached
 
           translated = translate_in(expanded, context.deeper)
-          @closed_alias_translations[expanded] = translated if closed_type?(expanded)
+          memo[expanded] = translated if closed_type?(expanded)
           translated
         end
 
+        # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion, lives with the expander.
+        # Closed means no `self`, `instance` or type variable anywhere inside, so the caller's context cannot change
+        # the answer; at expansion depth 0 the budget cannot either. But a nested alias inside the expansion is
+        # expanded through the expander (`type a = b | Integer` holds `b`), so the translation reads the expander's
+        # environment: a memo shared by every expander answered a second loader, whose `b` differs, with the first
+        # loader's translation (equal expansions are equal keys). The expander owns its memo, so it dies with it. An
+        # expander that offers none (anything answering only `expand_type_alias`) is translated afresh each time.
+        def closed_translations_of(expander)
+          expander.closed_alias_translations if expander.respond_to?(:closed_alias_translations)
+        end
+
         # True when nothing in `rbs_type`'s tree reads the translation context: no `self`, no `instance`,
         # no type variable. Every rbs type answers `each_type` (the leaves through `EmptyEachType`).
         def closed_type?(rbs_type)

data/lib/rigor/inference/receiver_alias.rb

@@ -85,6 +85,26 @@ module Rigor
         candidates(first, depth + 1) + candidates(second, depth + 1)
       end
 
+      # Calls whose result hands its caller the receiver's own element objects (issue #2287): `h.values` the hash's
+      # values, `a.dup` / `a.clone` a shallow copy sharing them, and the blockless enumerator spellings (`a.each`,
+      # `a.map`, `a.each_with_index`, `e.with_index`) the elements themselves.
+      ELEMENT_EXPOSING_CALLS = %i[values dup clone each map each_with_index with_index].to_set.freeze
+      private_constant :ELEMENT_EXPOSING_CALLS
+
+      # The variables whose elements a loop over `receiver` is handed: {.candidates} of `receiver` once every
+      # blockless {ELEMENT_EXPOSING_CALLS} call is peeled off, so `h.values.each { |v| v << 2 }` and
+      # `a.each_with_index.map { |x, i| x << i }` name `h` and `a`. Only a loop's element widening reads it; an
+      # in-place mutation OF such a result (`h.values << 1`, `a.dup << 1`) changes a new object, not the variable.
+      def element_sources(receiver)
+        depth = 0
+        while receiver.is_a?(Prism::CallNode) && receiver.block.nil? && ELEMENT_EXPOSING_CALLS.include?(receiver.name)
+          return [] if (depth += 1) > WALK_DEPTH_CAP
+
+          receiver = receiver.receiver
+        end
+        candidates(receiver)
+      end
+
       # The variable reads an in-place mutation of `receiver` changes: {.candidates}' locals and instance
       # variables, or the class variable or global the receiver reads or writes directly, parenthesised or not
       # (`(@@c ||= []) << x` mutates `@@c`, as `(buf ||= []) << x` mutates `buf`). A class variable or global counts

data/lib/rigor/inference/receiver_writer_call.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    # Issue #2488 — a writer a class gains from a call on an explicit receiver outside its body: `E.attr_writer :w`,
+    # `E.send(:attr_accessor, :y)`, `E.define_method(:set) { @v = … }` (and `define_method` through `send`). Ruby made
+    # `attr_*` and `define_method` public in 2.5, so each is the receiver class's own declaration, exactly as the same
+    # call in a `E.class_eval { … }` block is. Both ivar censuses read the calls through here: the per-file class-ivar
+    # walk ({ScopeIndexer}) and the cross-file {IvarWriterCensus}. The receiver's name is the caller's to resolve, the
+    # same way each resolves a `class_eval` receiver.
+    module ReceiverWriterCall
+      SEND_CALLS = %i[send __send__ public_send].to_set.freeze
+      WRITER_MACROS = %i[attr_writer attr_accessor].to_set.freeze
+      # The names a direct call spells; a `send` reaches any of them through its literal first argument.
+      CALLS = (WRITER_MACROS | SEND_CALLS | %i[define_method]).freeze
+      NO_ARGUMENTS = [].freeze
+
+      module_function
+
+      # The receiver of `node` when it is one of these calls on a receiver other than `self`, else nil.
+      def receiver(node)
+        return nil unless node.is_a?(Prism::CallNode) && CALLS.include?(node.name)
+
+        recv = node.receiver
+        recv unless recv.nil? || recv.is_a?(Prism::SelfNode)
+      end
+
+      # The ivar names an explicit-receiver `attr_writer` / `attr_accessor` declares (`[:@w]`), or an empty Array.
+      def writer_ivars(node)
+        name, arguments = called(node)
+        return NO_ARGUMENTS unless WRITER_MACROS.include?(name)
+
+        arguments.filter_map do |argument|
+          text = literal_name(argument)
+          :"@#{text}" if text
+        end
+      end
+
+      # The literal block an explicit-receiver `define_method` installs as an instance method, or nil.
+      def define_method_block(node)
+        name, = called(node)
+        block = node.block
+        block if name == :define_method && block.is_a?(Prism::BlockNode)
+      end
+
+      # The method `node` calls and its arguments, seen through a `send` whose first argument spells the name.
+      def called(node)
+        return [nil, NO_ARGUMENTS] if receiver(node).nil?
+
+        arguments = node.arguments&.arguments || NO_ARGUMENTS
+        return [node.name, arguments] unless SEND_CALLS.include?(node.name)
+
+        sent = literal_name(arguments.first)
+        sent ? [sent, arguments.drop(1)] : [nil, NO_ARGUMENTS]
+      end
+
+      def literal_name(argument)
+        return unless argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+
+        text = argument.unescaped
+        text.to_sym if text.valid_encoding?
+      end
+    end
+  end
+end