rigortype 0.4.3 → 0.4.4

data/lib/rigor/inference/narrowing.rb

@@ -511,7 +511,8 @@ module Rigor
       # none of the condition shapes are recognised, both returned scopes equal the input
       # scope. The catalogue mirrors {.case_equality_target_class}: static class/module
       # constants narrow as `is_a?`; integer/float-endpoint ranges narrow to `Numeric`;
-      # string-endpoint ranges and regexp literals narrow to `String`.
+      # string-endpoint ranges and regexp literals narrow to `String`; a `nil`, `true` or
+      # `false` literal narrows as its class does ({.when_condition_class}).
       def case_when_scopes(subject, conditions, scope)
         # C1 — `case x when /re/` runs `/re/ === x`, which sets the regex match-data globals
         # exactly as a successful `=~` does. Narrow `$~`/`$&`/`$1..$N` on the clause body (the
@@ -535,6 +536,30 @@ module Rigor
       CASE_SUBJECT_KINDS = %i[local ivar global constant].freeze
       private_constant :CASE_SUBJECT_KINDS
 
+      # Returns `[body_scope, falsey_scope]` for one clause of a `case` with a subject: a `when` clause narrows
+      # through {.case_when_scopes}, and an `in` clause only for a bare class pattern ({.bare_class_pattern_node}),
+      # which matches exactly when `subject.is_a?(C)`. Every other pattern can fail to match where a class test
+      # passes (deconstruction arity, hash keys, a guard), so it narrows neither edge. The pattern's bindings are
+      # the caller's to apply.
+      def case_clause_scopes(subject, clause, scope)
+        return case_when_scopes(subject, clause.conditions, scope) if clause.is_a?(Prism::WhenNode)
+
+        class_node = bare_class_pattern_node(clause.pattern)
+        class_node ? case_when_scopes(subject, [class_node], scope) : [scope, scope]
+      end
+
+      # ADR-47 WD3a — the class-constant node of a `in C` / `in C => x` pattern (the only `in` shapes whose match is
+      # pure `is_a?`), or nil for any pattern that deconstructs, binds, or matches a value.
+      def bare_class_pattern_node(pattern)
+        case pattern
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          pattern
+        when Prism::CapturePatternNode
+          value = pattern.value
+          value if value.is_a?(Prism::ConstantReadNode) || value.is_a?(Prism::ConstantPathNode)
+        end
+      end
+
       # When the clause has exactly one `RegularExpressionNode` literal condition, narrow the
       # match-data globals on the body edge (same rule as `analyse_regex_match_predicate`'s
       # truthy edge). With multiple regex conditions (`when /a/, /b/`) the body is reachable
@@ -1088,12 +1113,17 @@ module Rigor
         # in {Rigor::Builtins::RegexRefinement::RULES}, the truthy branch narrows further than
         # `String` to the matching imported refinement (e.g. `decimal-int-string` for `\d+`).
         # Bodies outside the table fall back to the v0.1.0 baseline (plain `String`).
+        #
+        # The match rebinds `$~` and the other match globals on both edges, and this rule binds none of them (#1482),
+        # so each edge forgets what an earlier match bound. The statement evaluator's walk already forgets them in the
+        # scope the match leaves; the per-node scope walk of a conditional it did not enter narrows from the scope
+        # before the match, where the falsey edge of an earlier `=~` had bound `$1` to `nil` (#1495).
         def analyse_match_write(node, scope)
           string_t = Type::Combinator.nominal_of("String")
           nil_t = Type::Combinator.constant_of(nil)
           refinements = match_write_capture_refinements(node)
-          truthy = scope
-          falsey = scope
+          truthy = scope.forget_match_globals
+          falsey = truthy
           node.targets.each do |target|
             next unless target.is_a?(Prism::LocalVariableTargetNode)
 
@@ -1575,23 +1605,59 @@ module Rigor
         end
 
         # Survey item (b): `/regex/ =~ str` and `str =~ /regex/` bind the regex match-data
-        # globals on each edge.
+        # globals on each edge ({#regex_match_edges}), gated on the subject (#1494): an edge is
+        # narrowed only when the receiver proves what the frame holds on it
+        # ({#match_receiver_edges}), and an edge it cannot vouch for keeps the match globals
+        # forgotten. A `String?` subject keeps the match edge only, since `NilClass#=~` answers
+        # nil with the previous match still bound; an untyped one is read the same way.
         #
-        # - Truthy edge (`=~` returned an Integer position — the match succeeded): `$~` to
+        # Returns nil (no narrowing) when the receiver / argument pair does not resolve to exactly one
+        # regex pattern we can count (see {#regex_match_pattern}).
+        def analyse_regex_match_predicate(node, scope)
+          gated_regex_match_edges(node, scope)
+        end
+
+        # Issue #1379 — `subject !~ pattern` is `Kernel#!~`, which returns `!(subject =~ pattern)`. It runs the same
+        # match in the caller's frame, so its edges are {#analyse_regex_match_predicate}'s swapped: the falsey edge is
+        # the match edge (`$~` a `MatchData`, an unconditional `$N` a `String`, and the whole-receiver refinement), the
+        # truthy edge the no-match edge (`$~` and `$N` nil). The same patterns are recognised and the same ones
+        # declined (a non-regex operand, an ambiguous constant, `//x`), and the receiver gates the edges alike.
+        def analyse_regex_not_match_predicate(node, scope)
+          gated_regex_match_edges(node, scope)&.reverse
+        end
+
+        # `[match_edge, no_match_edge]` of a `=~` / `!~` predicate, each kept only where
+        # {#match_receiver_edges} lets it be; an edge it cannot vouch for is the entry scope with the
+        # match globals forgotten, since the call may still have rebound them. The whole-receiver
+        # refinement is kept only when the local it would narrow is known to be a String on the
+        # match edge ({#refinable_operand?}).
+        def gated_regex_match_edges(node, scope)
+          edges = regex_match_edges(node, scope, refine: refinable_operand?(node, scope))
+          return nil if edges.nil?
+
+          match, no_match = edges
+          forgotten = scope.forget_match_globals
+          case match_receiver_edges(node, scope)
+          when :both then [match, no_match]
+          when :match then [match, forgotten]
+          else [forgotten, forgotten]
+          end
+        end
+
+        # The ungated edges of a match:
+        #
+        # - Match edge (`=~` returned an Integer position — the match succeeded): `$~` to
         #   `Nominal[MatchData]`; `$&` and `$1..$N` (where N is the number of capture groups in
         #   the regex source) to `Nominal[String]`. This is the same optimistic-narrowing shape
         #   the existing `analyse_match_write` uses for named captures inside `if /(?<x>...)/
         #   =~ str` — optional groups in the regex source (`(\d+)?`) would bind `$N` to `nil`
         #   at runtime, but the floor here matches the common idiom (required captures) and
         #   lets `unless /(\d+)/ =~ s; raise; end; $1.to_i` resolve cleanly.
-        # - Falsey edge (`=~` returned nil — no match): `$~` and every numbered / back-reference
+        # - No-match edge (`=~` returned nil): `$~` and every numbered / back-reference
         #   global bound to `Constant<nil>`.
         #
-        # Returns nil (no narrowing) when the receiver / argument pair does not resolve to exactly one
-        # regex pattern we can count (see {#regex_match_pattern}).
-        #
         # `refine: false` leaves out the whole-receiver refinement, which names a String.
-        def analyse_regex_match_predicate(node, scope, refine: true)
+        def regex_match_edges(node, scope, refine:)
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
@@ -1615,90 +1681,113 @@ module Rigor
           [truthy, falsey]
         end
 
-        # Issue #1379 — `subject !~ pattern` is `Kernel#!~`, which returns `!(subject =~ pattern)`. It runs the same
-        # match in the caller's frame, so its edges are {#analyse_regex_match_predicate}'s swapped: the falsey edge is
-        # the match edge (`$~` a `MatchData`, an unconditional `$N` a `String`, and the whole-receiver refinement), the
-        # truthy edge the no-match edge (`$~` and `$N` nil). The same patterns are recognised and the same ones
-        # declined (a non-regex operand, an ambiguous constant, `//x`).
-        #
-        # Unlike `=~`'s, an edge here is narrowed only when the receiver proves what the frame holds on it
-        # ({#not_match_receiver_edges}). An edge it cannot vouch for keeps the match globals forgotten, since the call
-        # may still have rebound them. The refinement is kept only when the local it would narrow is known to be a
-        # String on the match edge ({#refinable_operand?}).
-        def analyse_regex_not_match_predicate(node, scope)
-          edges = analyse_regex_match_predicate(node, scope, refine: refinable_operand?(node, scope))
-          return nil if edges.nil?
-
-          match, no_match = edges
-          forgotten = scope.forget_match_globals
-          case not_match_receiver_edges(node, scope)
-          when :both then [no_match, match]
-          when :match then [forgotten, match]
-          else [forgotten, forgotten]
-          end
-        end
-
-        # Which edges of `recv !~ pattern` the receiver lets {#analyse_regex_not_match_predicate} narrow. `Kernel#!~`
-        # dispatches `=~` on the receiver:
+        # Which edges of `recv =~ pattern` / `recv !~ pattern` the receiver lets {#gated_regex_match_edges} narrow:
+        # `:both`, `:match` (the match edge only) or nil. `Kernel#!~` dispatches `=~` on the receiver:
         #
         # - A Regexp receiver (the pattern on the left) runs `Regexp#=~`, which sets `$~` on both outcomes, a `nil`
         #   argument included: `:both`.
-        # - `String#=~` and `Symbol#=~` do the same: `:both` when every member of the receiver's type is a String or a
-        #   Symbol.
+        # - `String#=~` and `Symbol#=~` do the same: `:both` when every member of the receiver's type is a String
+        #   (a project subclass of String included) or a Symbol.
         # - `NilClass#=~` answers nil and leaves `$~` alone, so a nil receiver reaches the no-match edge with the
         #   previous match still bound; it never reaches the match edge. A `Dynamic` receiver may be nil at run time
-        #   whatever its static facet says: `:match` when every member is a String, a Symbol, nil, or a `Dynamic`
-        #   that is untyped or whose facet holds only those.
-        # - Any other receiver may define `=~` in Ruby, which binds `$~` in its own frame, not the caller's: nil.
+        #   whatever its static facet says. So does a safe-navigation call, which answers nil without matching on a
+        #   nil receiver.
         #
-        # A safe-navigation `recv&.!~(pattern)` answers nil without matching on a nil receiver, so it declines too.
-        def not_match_receiver_edges(node, scope)
-          return nil if node.receiver.nil? || node.safe_navigation?
-          return :both if regex_operand_pattern(node.receiver, scope).is_a?(RegexMatchPattern)
+        # The two operators part over a receiver that is none of those ({#match_operator_edges},
+        # {#not_match_operator_edges}).
+        def match_receiver_edges(node, scope)
+          return nil if node.receiver.nil?
+
+          edges =
+            if regex_operand_pattern(node.receiver, scope).is_a?(RegexMatchPattern)
+              :both
+            else
+              kinds = match_member_kinds(scope.type_of(node.receiver), scope)
+              node.name == :=~ ? match_operator_edges(kinds) : not_match_operator_edges(kinds)
+            end
+          return edges unless node.safe_navigation?
 
-          kinds = not_match_member_kinds(scope.type_of(node.receiver), scope)
-          return :both if kinds.all? { |kind| %i[string symbol].include?(kind) }
+          :match if edges && node.name == :=~
+        end
+
+        STRING_MATCH_KINDS = %i[string string_subclass symbol].freeze
+        private_constant :STRING_MATCH_KINDS
 
-          :match if kinds.all? { |kind| %i[string symbol nil dynamic].include?(kind) }
+        # `recv =~ pattern`'s match edge is the truthy one. Only a member known to define its own `=~` in the
+        # project keeps it out (#1494): that method binds `$~` in its own frame, not the caller's. Any other member
+        # either matches in the caller's frame, answers nil (`NilClass`), or has no `=~` at all (`Integer` since
+        # Ruby 3.2 drops `Object#=~`) and so never reaches the edge; a receiver the analyzer cannot classify keeps the
+        # edge, as every `=~` did before #1494.
+        def match_operator_edges(kinds)
+          return nil if kinds.include?(:custom)
+          return :both if kinds.all? { |kind| STRING_MATCH_KINDS.include?(kind) }
+
+          :match
+        end
+
+        # `recv !~ pattern`'s match edge is the falsey one, which a receiver whose `=~` is not the caller's match
+        # also reaches, so it is kept only when every member is a String, a Symbol, nil, or a `Dynamic` that is
+        # untyped or whose facet holds only those (#1379).
+        def not_match_operator_edges(kinds)
+          return :both if kinds.all? { |kind| STRING_MATCH_KINDS.include?(kind) }
+
+          :match if kinds.all? { |kind| (STRING_MATCH_KINDS + %i[nil dynamic]).include?(kind) }
         end
 
         # Whether the local operand {#apply_whole_receiver_refinement} would narrow holds only Strings and nil, which
         # the match edge excludes. The refinement names a String, so a member that may be a Symbol — a Symbol, or an
-        # untyped `Dynamic` that `Kernel#!~` accepts as the receiver or `Regexp#=~` as the argument — keeps it out:
-        # `return if raw !~ /\A\d+\z/` on an untyped `raw` must not make `raw.to_proc` an undefined method.
+        # untyped `Dynamic` that may be one at run time — keeps it out: `return unless raw =~ /\A\d+\z/` on an untyped
+        # `raw` must not make `raw.to_proc` an undefined method (#1379, #1494).
         def refinable_operand?(node, scope)
           operand = [node.receiver, *node.arguments&.arguments].find { |o| o.is_a?(Prism::LocalVariableReadNode) }
           type = operand && scope.local(operand.name)
           return true if type.nil?
 
-          not_match_member_kinds(type, scope).all? { |kind| %i[string nil].include?(kind) }
+          match_member_kinds(type, scope).all? { |kind| %i[string nil].include?(kind) }
         end
 
-        def not_match_member_kinds(type, scope)
-          (type.is_a?(Type::Union) ? type.members : [type]).map { |member| not_match_member_kind(member, scope) }
+        def match_member_kinds(type, scope)
+          (type.is_a?(Type::Union) ? type.members : [type]).map { |member| match_member_kind(member, scope) }
         end
 
-        # `:string` or `:symbol` for a member {.narrow_not_class} proves a String or a Symbol (a value or refinement of
-        # either, or a class the environment orders below it; a project subclass it cannot order reads as neither),
-        # `:nil`, `:dynamic` for a `Dynamic` whose facet is untyped or holds only Strings, Symbols and nil, or nil for
-        # anything else.
-        def not_match_member_kind(member, scope)
-          return not_match_dynamic_kind(member, scope) if member.is_a?(Type::Dynamic)
+        # `:custom` for a member whose class the project gives a `=~` of its own (in its ancestry, a reopened
+        # `String` included); `:string` or `:symbol` for a member {.narrow_not_class} proves a String or a Symbol (a
+        # value or refinement of either, or a class the environment orders below it); `:string_subclass` for a
+        # project class whose superclass chain reaches `String`, which the environment cannot order; `:nil`;
+        # `:dynamic` for a `Dynamic` whose facet is untyped or holds only Strings, Symbols and nil; or nil for anything
+        # else.
+        def match_member_kind(member, scope)
+          return match_dynamic_kind(member, scope) if member.is_a?(Type::Dynamic)
           return :nil if narrow_nil(member) == member && !member.is_a?(Type::Bot)
+          return :custom if custom_match_operator?(member, scope)
 
           environment = scope.environment
           { "String" => :string, "Symbol" => :symbol }.each do |class_name, kind|
             return kind if narrow_not_class(member, class_name, environment: environment, scope: scope).is_a?(Type::Bot)
           end
-          nil
+          :string_subclass if project_string_subclass?(member, scope)
         end
 
-        def not_match_dynamic_kind(member, scope)
+        def match_dynamic_kind(member, scope)
           facet = member.static_facet
           return :dynamic if facet.is_a?(Type::Top)
 
-          facet_kinds = not_match_member_kinds(facet, scope)
-          :dynamic if facet_kinds.all? { |kind| %i[string symbol nil].include?(kind) }
+          facet_kinds = match_member_kinds(facet, scope)
+          :dynamic if facet_kinds.all? { |kind| (STRING_MATCH_KINDS + [:nil]).include?(kind) }
+        end
+
+        def custom_match_operator?(member, scope)
+          targets = ProjectMethodOwnership.targets(member)
+          return false if targets.nil?
+
+          targets.any? { |class_name, kind| ProjectMethodOwnership.defines?(class_name, :=~, kind, scope) }
+        end
+
+        def project_string_subclass?(member, scope)
+          return false unless member.is_a?(Type::Nominal) && scope.known_user_class?(member.class_name)
+
+          scope.external_ancestor_name_candidates(member.class_name, mixins: false)
+               .flatten.any? { |name| name.to_s.delete_prefix("::") == "String" }
         end
 
         # `str.match?(/\A\d+\z/)` — `String#match?` is a pure boolean predicate whose truthy edge
@@ -2626,6 +2715,21 @@ module Rigor
           ]
         end
 
+        # The class a `when` condition narrows the subject to, as `is_a?` would, or nil when the condition is no class
+        # test Rigor reads: a class or module constant, a range or regexp literal ({.case_equality_target_class}),
+        # or (#1925) a `nil` / `true` / `false` literal. `nil === x` runs `NilClass#===`, which holds only for `nil`
+        # itself whatever the subject's class defines, and `nil` is `NilClass`'s only instance, so `when nil` is
+        # `when NilClass`; `true` and `false` likewise.
+        def when_condition_class(condition, scope)
+          lexical_class_name(condition, scope) || case_equality_target_class(condition) ||
+            SINGLETON_WHEN_LITERAL_CLASSES[unwrap_parens(condition).class]
+        end
+
+        SINGLETON_WHEN_LITERAL_CLASSES = {
+          Prism::NilNode => "NilClass", Prism::TrueNode => "TrueClass", Prism::FalseNode => "FalseClass"
+        }.freeze
+        private_constant :SINGLETON_WHEN_LITERAL_CLASSES
+
         # Maps a case-equality literal receiver to the class whose membership is implied by the
         # truthy edge. `Prism::ParenthesesNode` wrappers are transparently unwrapped (`(1..10)
         # === x` is parsed with the range inside parentheses).  Range literals: integer
@@ -2818,15 +2922,15 @@ module Rigor
         # narrowed type for the subject as if `condition === subject`, and accumulates them.
         # The body's narrowed type is the union across all conditions; the falsey type is the
         # running result after subtracting every condition's class. Conditions whose shape we
-        # cannot statically classify are treated as "no narrowing": the body falls back to the
-        # union of what we did learn (or the entry type when nothing learned), and the falsey
-        # edge is the entry type (because we cannot prove the unknown condition didn't match).
+        # cannot statically classify narrow neither edge: the body reads as
+        # {.case_when_body_type} says, and the falsey edge is the entry type.
         #
         # `[body type, next-clause type]` of a `when` clause's conditions over the subject type `current`.
         def case_when_types(scope, current, conditions)
           truthy_members = []
           falsey_type = current
           fully_narrowable = true
+          unread = false
 
           conditions.each do |condition|
             applied = apply_case_when_condition(scope, current, condition, falsey_type)
@@ -2835,12 +2939,24 @@ module Rigor
               falsey_type = applied[:falsey]
               fully_narrowable &&= applied[:fully_narrowable]
             else
+              unread = true
               fully_narrowable = false
             end
           end
 
-          truthy = truthy_members.empty? ? current : Type::Combinator.union(*truthy_members)
-          [truthy, fully_narrowable ? falsey_type : current]
+          [case_when_body_type(current, truthy_members, unread), fully_narrowable ? falsey_type : current]
+        end
+
+        # #1925 — the body type of a `when` clause. A clause whose conditions are all unread keeps the entry type. A
+        # clause mixing read conditions with an unread one reads `Dynamic[top]`: the body may run because the unread
+        # condition matched, so the read conditions' union is unsound (`when nil, ""` is not `nil`), and the entry
+        # type is wider than what reaches the body when the unread condition is itself a test
+        # (`when /a/, ->(v) { !v.nil? }` never enters with `nil`), so reading it would report a call no `nil` reaches.
+        def case_when_body_type(current, truthy_members, unread)
+          return current if truthy_members.empty?
+          return Type::Combinator.untyped if unread
+
+          Type::Combinator.union(*truthy_members)
         end
 
         # Per-condition rule. Returns `nil` when the condition shape is not recognised (caller
@@ -2855,7 +2971,7 @@ module Rigor
             return integer_literal_when_result(current, int_literal, falsey_acc)
           end
 
-          target = lexical_class_name(condition, scope) || case_equality_target_class(condition)
+          target = when_condition_class(condition, scope)
           return class_when_result(scope, current, target, falsey_acc) if target
 
           nil

data/lib/rigor/inference/reflective_ivar_write.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Issue #1889 — `instance_variable_set` called on `self` writes an instance variable that no write node shows.
+    # Left unseen, the binding the call site holds outlived it: `@n = 0; instance_variable_set(:@n, 5)` kept `@n`
+    # on `0`, and a block that wrote `@n` only this way never entered the captured-binding name set, so
+    # `[1, 2].inject(0) { |a, e| instance_variable_set(:@n, @n + 1); a + @n }` folded to a constant.
+    #
+    # A call counts when its receiver is implicit or `self` and it passes any argument ({.self_write?}). With
+    # exactly two plain positional arguments, the first a Symbol or String literal naming an instance variable
+    # (`:@n`, `"@n"`; Ruby accepts both), it is a write of that variable ({.literal_name}). Any other argument list
+    # — a computed name, a splat (`instance_variable_set(*args)`), a keyword hash, or a literal Ruby rejects with
+    # `NameError` (`:n`) — names an ivar the analysis cannot see, so every ivar the scope binds may have been
+    # written ({.apply}; for a rejected literal this over-approximates, which only widens).
+    # `obj.instance_variable_set` writes another object's ivar and does not count; neither does the reflective
+    # `send(:instance_variable_set, …)`.
+    module ReflectiveIvarWrite
+      METHOD_NAME = :instance_variable_set
+      private_constant :METHOD_NAME
+
+      IVAR_NAME = /\A@[A-Za-z_]\w*\z/
+      private_constant :IVAR_NAME
+
+      REPEATING_KEY = :__rigor_reflective_ivar_write_repeating__
+      private_constant :REPEATING_KEY
+
+      module_function
+
+      # True when `node` is an `instance_variable_set` on `self` with at least one argument.
+      def self_write?(node)
+        return false unless node.is_a?(Prism::CallNode) && node.name == METHOD_NAME
+        return false unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+        arguments = node.arguments&.arguments
+        !arguments.nil? && !arguments.empty?
+      end
+
+      # `:@n` for `instance_variable_set(:@n, v)` or `instance_variable_set("@n", v)` on `self`, else nil.
+      def literal_name(node)
+        return nil unless self_write?(node)
+
+        arguments = node.arguments.arguments
+        return nil unless arguments.size == 2 && arguments.none? { |arg| splat_or_keywords?(arg) }
+
+        name = arguments.first
+        text =
+          case name
+          when Prism::SymbolNode, Prism::StringNode then name.unescaped
+          end
+        text && IVAR_NAME.match?(text) ? text.to_sym : nil
+      end
+
+      # True for a call {.self_write?} takes whose target {.literal_name} cannot name: it may write any ivar.
+      def unknown_target?(node)
+        self_write?(node) && literal_name(node).nil?
+      end
+
+      # The value argument of a call {.literal_name} names.
+      def value_node(node)
+        node.arguments.arguments[1]
+      end
+
+      # Runs the block with the evaluator inside a `while` / `until` / `for` body. The loop's rebind fixpoint widens
+      # locals only, so a literal-name write there must not replace the binding with one pass's value
+      # ({.apply}).
+      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
+      end
+
+      def repeating_body?
+        (Thread.current[REPEATING_KEY] || 0).positive?
+      end
+
+      # `scope` after `node` runs. A literal name binds that ivar to the value's type (yielded), as `@n = v` does.
+      # Inside a loop body ({.in_repeating_body}) the value and `Dynamic[top]` are joined into the current binding
+      # instead: the loop's fixpoint widens locals only, so its single pass over an ivar types the value from one
+      # iteration's locals (`instance_variable_set(:@n, i + 1)` stored `1`) and would leave that. Any other call joins
+      # `Dynamic[top]` into every ivar `scope` binds: any one of them may now hold the value, and joining the
+      # value's own type would report a method the old value has and the new one lacks. An ivar on its ADR-58
+      # declaration seed keeps its mark, which stops a nil in the seed from fuelling a nil-receiver diagnostic.
+      def apply(node, scope)
+        return scope unless self_write?(node)
+
+        name = literal_name(node)
+        return bind_literal(scope, name, yield) if name
+
+        floor = Type::Combinator.untyped
+        scope.ivars.reduce(scope) do |acc, (ivar, type)|
+          widened = Type::Combinator.union(type, floor)
+          rebound = acc.with_ivar(ivar, widened).without_ivar_guard(ivar)
+          scope.declaration_sourced?(:ivar, ivar) ? rebound.seed_declaration_sourced_ivar(ivar, widened) : rebound
+        end
+      end
+
+      def bind_literal(scope, name, value)
+        type = repeating_body? ? Type::Combinator.union(*scope.ivar(name), value, Type::Combinator.untyped) : value
+        scope.with_ivar(name, type).without_ivar_guard(name)
+      end
+
+      def splat_or_keywords?(arg)
+        arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::KeywordHashNode) || arg.is_a?(Prism::BlockArgumentNode)
+      end
+    end
+  end
+end