rigortype 0.4.3 → 0.4.5

data/lib/rigor/inference/narrowing.rb

@@ -10,6 +10,7 @@ require_relative "../rbs_extended"
 require_relative "../analysis/fact_store"
 require_relative "../builtins/regex_refinement"
 require_relative "guard_rebinding"
+require_relative "intervening_ivar_reset"
 require_relative "key_presence_guard"
 require_relative "last_line"
 require_relative "operand_effects"
@@ -511,7 +512,9 @@ 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 narrow to `String`; regexp literals narrow as
+      # {.regexp_case_equality_type} says; 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 +538,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 +1115,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 +1607,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.
+        #
+        # 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:
         #
-        # - Truthy edge (`=~` returned an Integer position — the match succeeded): `$~` to
+        # - 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 +1683,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?
+
+          :match if edges && node.name == :=~
+        end
 
-          kinds = not_match_member_kinds(scope.type_of(node.receiver), scope)
-          return :both if kinds.all? { |kind| %i[string symbol].include?(kind) }
+        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
@@ -1708,9 +1799,13 @@ module Rigor
         # passes through unchanged (failing one pattern proves nothing about the string's shape).
         # A non-literal / unanchored / `\Z` / line-anchored / `//x` pattern falls through to no
         # narrowing.
+        #
+        # The refinement names a String, so it shares `=~`'s gate (#1955): a receiver that may be a Symbol, or an
+        # untyped one, is left as it is ({#refinable_operand?}).
         def analyse_whole_regex_match_predicate(node, scope)
           return nil unless node.receiver.is_a?(Prism::LocalVariableReadNode)
           return nil if node.arguments.nil? || node.arguments.arguments.size != 1
+          return nil unless refinable_operand?(node, scope)
 
           pattern = regex_operand_pattern(node.arguments.arguments.first, scope)
           return nil unless pattern.is_a?(RegexMatchPattern)
@@ -2547,10 +2642,10 @@ module Rigor
         #   iff the endpoints compare it. We conservatively narrow `x` to `Numeric` for
         #   integer-endpoint ranges and to `String` for string-endpoint ranges; other endpoint
         #   types fall through.
-        # - **Regexp literal receiver** (`/foo/ === x`): the match operator coerces `x` to a
-        #   String, so the truthy edge narrows `x` to `String`. The falsey edge keeps the entry
-        #   type unchanged because `Regexp#===` returns false for non-Strings AND for Strings
-        #   that simply do not match.
+        # - **Regexp literal receiver** (`/foo/ === x`): the truthy edge narrows `x` as
+        #   {#regexp_case_equality_type} says (its String and Symbol parts, #1955). The falsey edge
+        #   keeps the entry type unchanged because `Regexp#===` returns false for non-Strings AND
+        #   for Strings that simply do not match.
         #
         # Anything else — non-local LHS argument, dynamic receiver, custom `===` method — falls
         # through to the no-narrowing branch (nil), preserving the entry scope on both edges.
@@ -2614,6 +2709,9 @@ module Rigor
           if (class_name = lexical_class_name(receiver, scope))
             return class_predicate_scopes(scope, local_name, current, class_name, exact: false)
           end
+          if regexp_literal?(receiver)
+            return [scope.with_local(local_name, regexp_case_equality_type(current, scope)), scope]
+          end
 
           target_class = case_equality_target_class(receiver)
           return nil if target_class.nil?
@@ -2626,11 +2724,27 @@ 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 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
-        # endpoints → `Numeric`; string endpoints → `String`. Regexp literals → `String`. Other
-        # shapes return nil so the caller falls through.
+        # endpoints → `Numeric`; string endpoints → `String`. Regexp literals → `String`, read only
+        # as the class a dead `when` arm names: their narrowing is {#regexp_case_equality_type}'s,
+        # which the callers consult first. Other shapes return nil so the caller falls through.
         def case_equality_target_class(receiver)
           receiver = unwrap_parens(receiver)
           case receiver
@@ -2639,6 +2753,33 @@ module Rigor
           end
         end
 
+        def regexp_literal?(node)
+          case unwrap_parens(node)
+          when Prism::RegularExpressionNode, Prism::InterpolatedRegularExpressionNode then true
+          else false
+          end
+        end
+
+        # Issue #1955 — the subject on the match edge of `/re/ === x` (and of `case x when /re/`). `Regexp#===`
+        # matches a String, a Symbol by its name, and an object that converts with `to_str`, and answers false for
+        # anything else. Each member narrows to its String and Symbol parts: a `String | nil` subject reads `String`, a
+        # Symbol one stays `Symbol`. The `to_str` conversion is not modelled, so a member that defines `to_str` and is
+        # neither drops out of the edge. A `Dynamic` member is left as it is, since it may be a Symbol at run time. The
+        # no-match edge keeps the entry type: a String that does not match reaches it too.
+        def regexp_case_equality_type(current, scope)
+          members = current.is_a?(Type::Union) ? current.members : [current]
+          Type::Combinator.union(*members.map { |member| regexp_case_equality_member(member, scope) })
+        end
+
+        def regexp_case_equality_member(member, scope)
+          return member if member.is_a?(Type::Dynamic)
+
+          parts = %w[String Symbol].map do |class_name|
+            narrow_class(member, class_name, exact: false, environment: scope.environment, scope: scope)
+          end
+          Type::Combinator.union(*parts)
+        end
+
         def unwrap_parens(node)
           while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) &&
                 node.body.body.size == 1
@@ -2818,15 +2959,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 +2976,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 +3008,11 @@ module Rigor
             return integer_literal_when_result(current, int_literal, falsey_acc)
           end
 
-          target = lexical_class_name(condition, scope) || case_equality_target_class(condition)
+          if regexp_literal?(condition)
+            return { truthy: regexp_case_equality_type(current, scope), falsey: falsey_acc, fully_narrowable: true }
+          end
+
+          target = when_condition_class(condition, scope)
           return class_when_result(scope, current, target, falsey_acc) if target
 
           nil
@@ -3677,9 +3834,12 @@ module Rigor
         # that edge, so a `$_` the earlier operand narrowed is forgotten when the operand may set it
         # (`gets && log(items.each { gets })`), before the operand's own edges narrow it again.
         # Issue #1429 — likewise a guard's narrowing of a global or constant the operand may rebind
-        # (`$sep && reset_sep && $sep.length`).
+        # (`$sep && reset_sep && $sep.length`). Issue #1963 — and an instance variable's narrowing an implicit-self
+        # or `self.` call in the operand may write ({InterveningIvarReset.after_operand}): `@x.nil? && reset!` does
+        # not leave `@x` `nil` when `reset!` assigns it.
         def operand_edges(node, edge_scope)
           edge_scope = LastLine.forget_if_set(edge_scope, node)
+          edge_scope = InterveningIvarReset.after_operand(node, edge_scope)
           if edge_scope.guard_narrowed? && GuardRebinding.may_rebind?(node, edge_scope)
             edge_scope = edge_scope.forget_guard_narrowings
           end

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "scope_indexer"
+require_relative "project_seed_tables"
 require_relative "fork_map"
 require_relative "../source/node_walker"
 
@@ -238,18 +239,10 @@ module Rigor
         base.with_discovery(base.discovery.with(**tables))
       end
 
+      # Issue #1614 — the tables a `check` run seeds, from the one list {ProjectSeedTables} keeps for every path that
+      # runs no `check`, so an argument types here as it does in the file `check` analyses.
       def discovery_seed_tables
-        classes = ScopeIndexer.discovered_classes_for_paths(@files)
-        def_index = ScopeIndexer.discovered_def_index_for_paths(@files)
-        tables = {}
-        tables[:discovered_classes] = classes unless classes.empty?
-        DISCOVERY_FIELD.each do |index_key, field|
-          table = def_index.fetch(index_key)
-          tables[field] = table unless table.empty? && !Scope::DiscoveryIndex.paired?(field)
-        end
-        # ADR-119 WD1 — the pairs travel together: a pair is dropped only when both halves are empty. A sibling whose
-        # member this collector does not seed completes to that member's empty value, which the base scope holds.
-        Scope::DiscoveryIndex.compact_pairs(tables.merge(def_index.fetch(:siblings)))
+        ProjectSeedTables.for_paths(@files)
       rescue StandardError => e
         # Discovery is best-effort; a malformed corner of the project must not crash the
         # protection scan. Without discovery the collector simply resolves fewer call sites. A broken
@@ -257,21 +250,6 @@ module Rigor
         e.is_a?(DeclarationWalk::ContractError) ? raise : {}
       end
 
-      DISCOVERY_FIELD = {
-        def_nodes: :discovered_def_nodes,
-        singleton_def_nodes: :discovered_singleton_def_nodes,
-        def_sources: :discovered_def_sources,
-        superclasses: :discovered_superclasses,
-        header_nestings: :discovered_header_nestings,
-        includes: :discovered_includes, unpositioned_mixins: :unpositioned_mixins,
-        class_sources: :discovered_class_sources,
-        method_visibilities: :discovered_method_visibilities,
-        methods: :discovered_methods,
-        data_member_layouts: :data_member_layouts,
-        struct_member_layouts: :struct_member_layouts, deferred_ranges: :discovered_deferred_ranges
-      }.freeze
-      private_constant :DISCOVERY_FIELD
-
       # Built once over the whole project and inherited by the fork workers via copy-on-write; a frozen Set
       # for O(1) membership in the {#record_call} hot loop.
       def user_method_names(discovery)