rigortype 0.1.10 → 0.1.12

data/lib/rigor/inference/statement_evaluator.rb

@@ -8,9 +8,11 @@ require_relative "../analysis/fact_store"
 require_relative "../source/node_walker"
 require_relative "block_parameter_binder"
 require_relative "closure_escape_analyzer"
+require_relative "indexed_narrowing"
 require_relative "method_dispatcher"
 require_relative "method_parameter_binder"
 require_relative "multi_target_binder"
+require_relative "mutation_widening"
 require_relative "narrowing"
 
 module Rigor
@@ -72,6 +74,7 @@ module Rigor
         Prism::GlobalVariableOrWriteNode => :eval_global_or_write,
         Prism::GlobalVariableAndWriteNode => :eval_global_and_write,
         Prism::GlobalVariableOperatorWriteNode => :eval_global_operator_write,
+        Prism::IndexOrWriteNode => :eval_index_or_write,
         Prism::MultiWriteNode => :eval_multi_write,
         Prism::IfNode => :eval_if,
         Prism::UnlessNode => :eval_unless,
@@ -300,6 +303,53 @@ module Rigor
         end
       end
 
+      # `receiver[key] ||= default` — the Redmine `Query#as_params`
+      # idiom (ROADMAP § Future cycles / Type-language / engine —
+      # "Indexed-collection narrowing through `Hash[k] ||= default`").
+      # After the `||=`, the next read at `receiver[key]` is known
+      # non-nil; the next `<<` / `[]=` / other mutator runs against
+      # a Tuple / Hash carrier instead of the `Constant[nil]` an
+      # empty `HashShape{}` lookup would otherwise fold to.
+      #
+      # The handler:
+      # 1. Types the equivalent `receiver[key]` read under the
+      #    entry scope (so any previously-recorded narrowing for
+      #    the same address is already applied).
+      # 2. Types the rvalue under the entry scope.
+      # 3. Computes `union(narrow_truthy(current), rhs)` — the
+      #    standard `||=` result shape used by locals / ivars /
+      #    cvars / globals.
+      # 4. Records the result type in the post-scope as a
+      #    narrowing keyed on `(receiver_kind, receiver_name,
+      #    literal_key)` when both receiver and key are stable
+      #    (see {Inference::IndexedNarrowing}). Unstable shapes
+      #    fall through to "no scope effect", matching the old
+      #    `Prism::IndexOrWriteNode` default-branch behaviour.
+      #
+      # The expression value is the result type, matching Ruby's
+      # semantics: `(x = params[:f] ||= []); x` observes the
+      # post-`||=` value, not the rvalue alone.
+      def eval_index_or_write(node)
+        rhs_type, post_rhs = sub_eval(node.value, scope)
+        current_type = scope.type_of(node, tracer: tracer)
+        result_type = Type::Combinator.union(Narrowing.narrow_truthy(current_type), rhs_type)
+
+        key_node = first_index_argument(node)
+        address = key_node && IndexedNarrowing.stable_address(node.receiver, key_node)
+        post = post_rhs
+        post = post.with_indexed_narrowing(*address, result_type) if address
+
+        [result_type, post]
+      end
+
+      def first_index_argument(node)
+        args = node.arguments
+        return nil if args.nil?
+
+        list = args.respond_to?(:arguments) ? args.arguments : args
+        list.first
+      end
+
       def dispatch_operator(current, rhs, operator)
         result = MethodDispatcher.dispatch(
           receiver_type: current,
@@ -519,8 +569,30 @@ module Rigor
       # joined exit scope so locals bound exclusively in `ensure` stay
       # observable.
       def eval_begin(node)
-        primary_type, primary_scope = eval_begin_primary(node)
-        rescue_chain = collect_rescue_chain_results(node.rescue_clause, scope)
+        entry = scope
+        primary_type, primary_scope = eval_begin_primary_under(node, entry)
+        rescue_chain = collect_rescue_chain_results(node.rescue_clause, entry)
+
+        # B2.1 — retry-edge widening. When any rescue body
+        # contains `Prism::RetryNode`, control re-enters the
+        # primary body with the rescue arm's rebinds visible.
+        # Today's flow loses that effect, so a counter like
+        # `tries = 0; ...; rescue; tries += 1; retry; end`
+        # observes `tries: Constant[0]` inside the body and any
+        # `tries > 100` predicate folds to always-falsey.
+        # The fix: widen rebound locals / ivars in any
+        # retry-emitting arm to their Nominal envelope (Constant
+        # → Nominal[<class>], Tuple → Array, HashShape → Hash),
+        # then re-evaluate primary body AND rescue chain once
+        # under the widened entry. Nominal envelope is the
+        # maximally widened form so the re-evaluation converges
+        # in one step.
+        widened_entry = widen_entry_for_retry(entry, rescue_chain)
+        if widened_entry
+          primary_type, primary_scope = eval_begin_primary_under(node, widened_entry)
+          rescue_chain = collect_rescue_chain_results(node.rescue_clause, widened_entry)
+        end
+
         # Rescue arms whose body unconditionally exits (`return`,
         # `next`, `break`, `raise`, `throw`, `exit`, `abort`,
         # `fail`) contribute neither a type fragment NOR a scope
@@ -556,11 +628,15 @@ module Rigor
       # body's scope effects still apply because the body did run
       # before the else.
       def eval_begin_primary(node)
+        eval_begin_primary_under(node, scope)
+      end
+
+      def eval_begin_primary_under(node, entry_scope)
         body_type, body_scope =
           if node.statements
-            sub_eval(node.statements, scope)
+            sub_eval(node.statements, entry_scope)
           else
-            [Type::Combinator.constant_of(nil), scope]
+            [Type::Combinator.constant_of(nil), entry_scope]
           end
 
         if node.else_clause
@@ -571,6 +647,105 @@ module Rigor
         end
       end
 
+      # B2.1 — return a widened entry scope when at least one
+      # rescue arm in `rescue_chain` contains a `Prism::RetryNode`
+      # AND that arm rebinds at least one local or ivar relative
+      # to the original entry. Returns nil when no widening is
+      # needed (no retry, or no rebinds reachable across the
+      # retry edge).
+      #
+      # Always-safe: the widening can only LOSE precision; it
+      # never invents a fact (Nominal envelope is a superset of
+      # the Constant / shape carrier it widens from). Convergent
+      # in one step because Nominal envelope is the maximally
+      # widened form against the engine's current carrier set.
+      def widen_entry_for_retry(entry_scope, rescue_chain)
+        widened = nil
+        rescue_chain.each do |(_arm_type, arm_post_scope), arm_node|
+          next unless arm_contains_retry?(arm_node)
+
+          accumulator = widened || entry_scope
+          accumulator = absorb_retry_rebinds(accumulator, entry_scope, arm_post_scope)
+          widened = accumulator
+        end
+        return nil if widened.nil? || widened == entry_scope
+
+        widened
+      end
+
+      def arm_contains_retry?(node)
+        return false unless node.is_a?(Prism::Node)
+        return true if node.is_a?(Prism::RetryNode)
+        # Don't descend into nested blocks / defs / classes /
+        # modules — a `retry` inside a nested method body or
+        # block targets its own enclosing `begin`, not this one.
+        return false if node.is_a?(Prism::DefNode) ||
+                        node.is_a?(Prism::ClassNode) ||
+                        node.is_a?(Prism::ModuleNode) ||
+                        node.is_a?(Prism::BlockNode)
+
+        node.compact_child_nodes.any? { |c| arm_contains_retry?(c) }
+      end
+
+      def absorb_retry_rebinds(accumulator, entry_scope, arm_post_scope)
+        scope_acc = accumulator
+        # Walk every local visible in either side, compare types,
+        # widen to Nominal envelope on a difference.
+        local_keys = arm_post_scope.locals.keys | entry_scope.locals.keys
+        local_keys.each do |name|
+          pre = entry_scope.local(name)
+          post = arm_post_scope.local(name)
+          next if pre == post || post.nil?
+
+          widened = retry_widened_type(pre, post)
+          scope_acc = scope_acc.with_local(name, widened)
+        end
+        ivar_keys = arm_post_scope.ivars.keys | entry_scope.ivars.keys
+        ivar_keys.each do |name|
+          pre = entry_scope.ivar(name)
+          post = arm_post_scope.ivar(name)
+          next if pre == post || post.nil?
+
+          widened = retry_widened_type(pre, post)
+          scope_acc = scope_acc.with_ivar(name, widened)
+        end
+        scope_acc
+      end
+
+      def retry_widened_type(pre, post)
+        # `pre` is nil when the local was introduced inside the
+        # rescue body. The retry edge brings it back into the
+        # primary body's entry — widen the post type itself.
+        envelope = nominal_envelope_for(post)
+        return envelope if pre.nil?
+
+        nominal_envelope_for(Type::Combinator.union(pre, envelope))
+      end
+
+      # Nominal envelope of a value type: widens Constant /
+      # Tuple / HashShape carriers to the underlying class's
+      # `Nominal`, preserving everything else (`Nominal`,
+      # `Union` of non-shape members, `Top`, `Dynamic`, `Bot`).
+      # Union members are walked individually.
+      def nominal_envelope_for(type)
+        members = type.is_a?(Type::Union) ? type.members : [type]
+        widened = members.map { |m| nominal_envelope_member(m) }
+        Type::Combinator.union(*widened)
+      end
+
+      def nominal_envelope_member(member)
+        case member
+        when Type::Constant
+          Type::Combinator.nominal_of(member.value.class.name)
+        when Type::Tuple
+          MutationWidening.widen_tuple(member)
+        when Type::HashShape
+          MutationWidening.widen_hash_shape(member)
+        else
+          member
+        end
+      end
+
       def collect_rescue_chain_results(rescue_node, entry_scope)
         results = []
         current = rescue_node
@@ -876,9 +1051,86 @@ module Rigor
         post_scope = apply_rbs_extended_assertions(node, post_scope)
         post_scope = apply_plugin_assertions(node, post_scope)
         post_scope = apply_rspec_matcher_narrowing(node, post_scope)
+        # Flow-folding G1 / G2 — widen a local- or instance-variable
+        # binding when the call is an in-place mutator on it (e.g.
+        # `arms << x`, `@tags << hashtag`). Stops a literal-shape
+        # carrier (`Tuple` / `HashShape`) from outliving its
+        # justification when the value is mutated. Always-safe
+        # (loses precision, never invents facts).
+        post_scope = MutationWidening.widen_after_call(call_node: node, current_scope: post_scope)
+        # And the same widening for outer-scope locals / ivars
+        # mutated inside the block body (`items.each { |x| arr << x }`):
+        # the block lives in a child scope so without an explicit
+        # propagation step the outer `arr` keeps its pre-mutation
+        # binding. Sound for the same reason — only ever LOSES
+        # precision — so blindly applying is safe regardless of
+        # whether the block actually runs.
+        post_scope = MutationWidening.widen_after_block(call_node: node, outer_scope: post_scope)
+        # Indexed-collection narrowing — drop any
+        # `receiver[key] ||= default` narrowing the analyzer
+        # recorded earlier when an intervening `[]=` writes the
+        # same slot or any other mutator runs against the
+        # receiver. Always-safe (only forgets; never invents).
+        post_scope = IndexedNarrowing.invalidate_after_call(call_node: node, current_scope: post_scope)
+        # Single-hop method-chain narrowing — drop every
+        # `(receiver, *)` chain narrowing rooted at the call's
+        # outer stable receiver (any-call-against-the-root
+        # invalidation rule, B2 from the slice's design
+        # notes). Calls whose outer receiver is itself a chain
+        # node (e.g. `x.last << y`) do NOT drop narrowings
+        # keyed on `x` — only direct calls against the root
+        # variable invalidate the chain.
+        post_scope = IndexedNarrowing.invalidate_chain_after_call(call_node: node, current_scope: post_scope)
+        # B2.2 — intervening method call ivar invalidation.
+        # An implicit-self / self-receiver call could mutate any
+        # ivar of the enclosing class (we cannot prove purity
+        # without an effect system). Reset each ivar whose
+        # current local binding has narrowed below the class-ivar
+        # seed back to the seed itself, so a subsequent
+        # `if @flag` predicate observes the seed's union (not the
+        # pre-call narrowed value). Always-safe (only widens; no
+        # new facts). See [`docs/CURRENT_WORK.md`](../../../docs/CURRENT_WORK.md)
+        # § "Flow-folding" — G2 intervening-call case.
+        post_scope = invalidate_ivars_for_intervening_call(node, post_scope)
         [call_type, post_scope]
       end
 
+      # Returns a scope with each ivar's narrowed local binding
+      # widened back to its class-ivar seed value when the call
+      # is one that could plausibly mutate ivars on the enclosing
+      # class (implicit-self or explicit `self.foo`). External-
+      # receiver calls (`obj.method`) cannot reach the caller's
+      # ivars; they pass through unchanged.
+      def invalidate_ivars_for_intervening_call(call_node, current_scope)
+        return current_scope unless intervening_call_candidate?(call_node)
+
+        class_name = enclosing_class_name_for(current_scope.self_type)
+        return current_scope if class_name.nil?
+
+        seed = current_scope.class_ivars_for(class_name)
+        return current_scope if seed.empty?
+
+        seed.reduce(current_scope) do |acc, (ivar_name, seed_type)|
+          local_type = current_scope.ivar(ivar_name)
+          next acc if local_type.nil? || local_type == seed_type
+
+          acc.with_ivar(ivar_name, Type::Combinator.union(local_type, seed_type))
+        end
+      end
+
+      def intervening_call_candidate?(call_node)
+        return false unless call_node.is_a?(Prism::CallNode)
+
+        receiver = call_node.receiver
+        receiver.nil? || receiver.is_a?(Prism::SelfNode)
+      end
+
+      def enclosing_class_name_for(self_type)
+        case self_type
+        when Type::Nominal, Type::Singleton then self_type.class_name
+        end
+      end
+
       def evaluate_def_arguments(call_node)
         args = call_node.arguments
         return unless args.respond_to?(:arguments)

data/lib/rigor/scope.rb

@@ -22,12 +22,50 @@ module Rigor
                 :discovered_classes, :in_source_constants, :discovered_methods,
                 :discovered_def_nodes, :discovered_method_visibilities,
                 :discovered_superclasses, :discovered_includes,
+                :indexed_narrowings, :method_chain_narrowings,
                 :source_path
 
+    # Narrowing key for an indexed read `receiver[key]` where both
+    # the receiver and the key are stable enough to address. The
+    # value of the map at this key is the narrowed type the next
+    # read at the same address MUST observe.
+    #
+    # - `receiver_kind` ∈ `{:local, :ivar}` — the analyzer only
+    #   tracks reads against a local or instance variable today.
+    # - `receiver_name` is the variable's Symbol.
+    # - `key` is the Ruby value of the literal index (Symbol /
+    #   String / Integer). Non-literal keys (`params[field]`) are
+    #   not recorded; they have no stable address.
+    IndexedKey = Data.define(:receiver_kind, :receiver_name, :key)
+
+    # Narrowing key for a no-arg / no-block method-call chain
+    # `receiver.method_name` (a "single-hop" chain per A1 from the
+    # ROADMAP § Future cycles slice). The value of the map at this
+    # key is the narrowed type the next read of the same chain
+    # MUST observe — typically the post-`is_a?(C)` narrowing
+    # established on a predicate edge.
+    #
+    # - `receiver_kind` ∈ `{:local, :ivar}` — the analyzer only
+    #   tracks chains rooted at a local or instance variable
+    #   today (Law-of-Demeter-style single-hop).
+    # - `receiver_name` is the root variable's Symbol.
+    # - `method_name` is the no-arg method invoked on the root.
+    #
+    # Chains with arguments (`x.first(3)`), with a block
+    # (`x.detect { ... }`), or with intermediate links
+    # (`x.foo.bar`) are NOT recorded; each loses stability for
+    # different reasons (args / block alter the call's return;
+    # multi-hop loses the LoD guarantee).
+    ChainKey = Data.define(:receiver_kind, :receiver_name, :method_name)
+
     EMPTY_DECLARED_TYPES = {}.compare_by_identity.freeze
     EMPTY_VAR_BINDINGS = {}.freeze
     EMPTY_CLASS_BINDINGS = {}.freeze
-    private_constant :EMPTY_DECLARED_TYPES, :EMPTY_VAR_BINDINGS, :EMPTY_CLASS_BINDINGS
+    EMPTY_INDEXED_NARROWINGS = {}.freeze
+    EMPTY_CHAIN_NARROWINGS = {}.freeze
+    private_constant :EMPTY_DECLARED_TYPES, :EMPTY_VAR_BINDINGS,
+                     :EMPTY_CLASS_BINDINGS, :EMPTY_INDEXED_NARROWINGS,
+                     :EMPTY_CHAIN_NARROWINGS
 
     class << self
       def empty(environment: Environment.default, source_path: nil)
@@ -54,6 +92,8 @@ module Rigor
       discovered_method_visibilities: EMPTY_CLASS_BINDINGS,
       discovered_superclasses: EMPTY_CLASS_BINDINGS,
       discovered_includes: EMPTY_CLASS_BINDINGS,
+      indexed_narrowings: EMPTY_INDEXED_NARROWINGS,
+      method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
       source_path: nil
     )
       @environment = environment
@@ -74,6 +114,8 @@ module Rigor
       @discovered_method_visibilities = discovered_method_visibilities
       @discovered_superclasses = discovered_superclasses
       @discovered_includes = discovered_includes
+      @indexed_narrowings = indexed_narrowings
+      @method_chain_narrowings = method_chain_narrowings
       @source_path = source_path
       freeze
     end
@@ -85,7 +127,19 @@ module Rigor
     def with_local(name, type)
       new_locals = @locals.merge(name.to_sym => type).freeze
       new_fact_store = fact_store.invalidate_target(Analysis::FactStore::Target.local(name))
-      rebuild(locals: new_locals, fact_store: new_fact_store)
+      # Rebinding `name` invalidates every "after `receiver[key]
+      # ||= default`" narrowing keyed on it — the slot at `name[*]`
+      # is reachable through the old binding only, so the
+      # next read against the new binding does not inherit the
+      # earlier non-nil guarantee. The same logic applies to
+      # method-chain narrowings: `x.last` after `x = something_new`
+      # is a call on the new binding and any prior `is_a?`-driven
+      # narrowing keyed on `(local, :x, :last)` no longer holds.
+      new_indexed_narrowings = drop_indexed_narrowings_for(:local, name)
+      new_chain_narrowings = drop_chain_narrowings_for(:local, name)
+      rebuild(locals: new_locals, fact_store: new_fact_store,
+              indexed_narrowings: new_indexed_narrowings,
+              method_chain_narrowings: new_chain_narrowings)
     end
 
     def with_fact(fact)
@@ -150,7 +204,11 @@ module Rigor
     end
 
     def with_ivar(name, type)
-      rebuild(ivars: @ivars.merge(name.to_sym => type).freeze)
+      new_indexed_narrowings = drop_indexed_narrowings_for(:ivar, name)
+      new_chain_narrowings = drop_chain_narrowings_for(:ivar, name)
+      rebuild(ivars: @ivars.merge(name.to_sym => type).freeze,
+              indexed_narrowings: new_indexed_narrowings,
+              method_chain_narrowings: new_chain_narrowings)
     end
 
     def with_cvar(name, type)
@@ -344,6 +402,79 @@ module Rigor
       rebuild(discovered_method_visibilities: table)
     end
 
+    # Closes the "`params[:f] ||= []; params[:f] << x`" precision
+    # gap (ROADMAP § Type-language / engine — indexed-collection
+    # narrowing through `Hash[k] ||= default`). After
+    # `receiver[key] ||= default`, the next read at `receiver[key]`
+    # is known non-nil; recording the post-`||=` type keyed on
+    # `(receiver_kind, receiver_name, literal_key)` lets the
+    # ExpressionTyper's `[]` dispatch hand back the narrowed
+    # type. Receiver-rebind and `[]=`/mutator invalidation rules
+    # are documented at the call sites in
+    # `Inference::StatementEvaluator`.
+    def indexed_narrowing(receiver_kind, receiver_name, key)
+      @indexed_narrowings[indexed_key(receiver_kind, receiver_name, key)]
+    end
+
+    def with_indexed_narrowing(receiver_kind, receiver_name, key, type)
+      new_table = @indexed_narrowings.merge(
+        indexed_key(receiver_kind, receiver_name, key) => type
+      ).freeze
+      rebuild(indexed_narrowings: new_table)
+    end
+
+    def without_indexed_narrowing(receiver_kind, receiver_name, key)
+      lookup = indexed_key(receiver_kind, receiver_name, key)
+      return self unless @indexed_narrowings.key?(lookup)
+
+      new_table = @indexed_narrowings.reject { |k, _| k == lookup }.freeze
+      rebuild(indexed_narrowings: new_table)
+    end
+
+    def without_indexed_narrowings_for(receiver_kind, receiver_name)
+      new_table = drop_indexed_narrowings_for(receiver_kind, receiver_name)
+      return self if new_table.equal?(@indexed_narrowings)
+
+      rebuild(indexed_narrowings: new_table)
+    end
+
+    # Closes the "stable receiver method-chain narrowing" gap
+    # (ROADMAP § Future cycles / Type-language / engine —
+    # "Method-call receiver narrowing across stable receivers";
+    # 2026-05-28 Redmine survey). After `if x.last.is_a?(Array)`
+    # the dominated body's `x.last` reads MUST observe the
+    # truthy-narrowed type; the same chain reaching the falsey
+    # edge observes the negative narrowing.
+    #
+    # Address shape mirrors {.indexed_narrowing}: stable root
+    # variable + no-arg single-hop method name. See
+    # {ChainKey} for the precise contract.
+    def method_chain_narrowing(receiver_kind, receiver_name, method_name)
+      @method_chain_narrowings[chain_key(receiver_kind, receiver_name, method_name)]
+    end
+
+    def with_method_chain_narrowing(receiver_kind, receiver_name, method_name, type)
+      new_table = @method_chain_narrowings.merge(
+        chain_key(receiver_kind, receiver_name, method_name) => type
+      ).freeze
+      rebuild(method_chain_narrowings: new_table)
+    end
+
+    def without_method_chain_narrowing(receiver_kind, receiver_name, method_name)
+      lookup = chain_key(receiver_kind, receiver_name, method_name)
+      return self unless @method_chain_narrowings.key?(lookup)
+
+      new_table = @method_chain_narrowings.reject { |k, _| k == lookup }.freeze
+      rebuild(method_chain_narrowings: new_table)
+    end
+
+    def without_method_chain_narrowings_for(receiver_kind, receiver_name)
+      new_table = drop_chain_narrowings_for(receiver_kind, receiver_name)
+      return self if new_table.equal?(@method_chain_narrowings)
+
+      rebuild(method_chain_narrowings: new_table)
+    end
+
     def facts_for(target: nil, bucket: nil)
       fact_store.facts_for(target: target, bucket: bucket)
     end
@@ -395,7 +526,9 @@ module Rigor
         self_type == other.self_type &&
         @ivars == other.ivars &&
         @cvars == other.cvars &&
-        @globals == other.globals
+        @globals == other.globals &&
+        @indexed_narrowings == other.indexed_narrowings &&
+        @method_chain_narrowings == other.method_chain_narrowings
     end
     alias eql? ==
 
@@ -414,6 +547,8 @@ module Rigor
       discovered_method_visibilities: @discovered_method_visibilities,
       discovered_superclasses: @discovered_superclasses,
       discovered_includes: @discovered_includes,
+      indexed_narrowings: @indexed_narrowings,
+      method_chain_narrowings: @method_chain_narrowings,
       source_path: @source_path
     )
       self.class.new(
@@ -430,6 +565,8 @@ module Rigor
         discovered_method_visibilities: discovered_method_visibilities,
         discovered_superclasses: discovered_superclasses,
         discovered_includes: discovered_includes,
+        indexed_narrowings: indexed_narrowings,
+        method_chain_narrowings: method_chain_narrowings,
         source_path: source_path
       )
     end
@@ -459,9 +596,49 @@ module Rigor
         discovered_method_visibilities: discovered_method_visibilities,
         discovered_superclasses: discovered_superclasses,
         discovered_includes: discovered_includes,
+        indexed_narrowings: join_bindings(@indexed_narrowings, other.indexed_narrowings),
+        method_chain_narrowings: join_bindings(@method_chain_narrowings, other.method_chain_narrowings),
         source_path: source_path
       )
     end
+
+    def indexed_key(receiver_kind, receiver_name, key)
+      IndexedKey.new(
+        receiver_kind: receiver_kind.to_sym,
+        receiver_name: receiver_name.to_sym,
+        key: key
+      )
+    end
+
+    def chain_key(receiver_kind, receiver_name, method_name)
+      ChainKey.new(
+        receiver_kind: receiver_kind.to_sym,
+        receiver_name: receiver_name.to_sym,
+        method_name: method_name.to_sym
+      )
+    end
+
+    def drop_indexed_narrowings_for(receiver_kind, receiver_name)
+      return @indexed_narrowings if @indexed_narrowings.empty?
+
+      sym_kind = receiver_kind.to_sym
+      sym_name = receiver_name.to_sym
+      filtered = @indexed_narrowings.reject do |k, _|
+        k.receiver_kind == sym_kind && k.receiver_name == sym_name
+      end
+      filtered.size == @indexed_narrowings.size ? @indexed_narrowings : filtered.freeze
+    end
+
+    def drop_chain_narrowings_for(receiver_kind, receiver_name)
+      return @method_chain_narrowings if @method_chain_narrowings.empty?
+
+      sym_kind = receiver_kind.to_sym
+      sym_name = receiver_name.to_sym
+      filtered = @method_chain_narrowings.reject do |k, _|
+        k.receiver_kind == sym_kind && k.receiver_name == sym_name
+      end
+      filtered.size == @method_chain_narrowings.size ? @method_chain_narrowings : filtered.freeze
+    end
   end
   # rubocop:enable Metrics/ClassLength,Metrics/ParameterLists
 end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.1.10"
+  VERSION = "0.1.12"
 end