rigortype 0.0.9 → 0.1.0

data/lib/rigor/inference/expression_typer.rb

@@ -65,6 +65,7 @@ module Rigor
         Prism::NilNode => :type_of_nil,
         # Locals
         Prism::LocalVariableReadNode => :local_read,
+        Prism::ItLocalVariableReadNode => :it_read,
         Prism::LocalVariableWriteNode => :type_of_assignment_write,
         # Containers and pass-throughs
         Prism::ArrayNode => :array_type_for,
@@ -171,9 +172,11 @@ module Rigor
         Prism::WhileNode => :type_of_loop,
         Prism::UntilNode => :type_of_loop,
         Prism::ForNode => :type_of_dynamic_top,
-        Prism::DefinedNode => :type_of_dynamic_top,
-        Prism::MatchPredicateNode => :type_of_dynamic_top,
-        Prism::MatchRequiredNode => :type_of_dynamic_top,
+        Prism::DefinedNode => :type_of_defined,
+        Prism::NumberedReferenceReadNode => :type_of_string_or_nil,
+        Prism::BackReferenceReadNode => :type_of_string_or_nil,
+        Prism::MatchPredicateNode => :type_of_match_predicate,
+        Prism::MatchRequiredNode => :type_of_match_required,
         Prism::MatchWriteNode => :type_of_dynamic_top,
         # Literal containers
         Prism::LambdaNode => :type_of_lambda,
@@ -298,6 +301,45 @@ module Rigor
         dynamic_top
       end
 
+      # `defined?(expr)` returns `String | nil` per Ruby semantics —
+      # a description of the expression's category (`"local-variable"`,
+      # `"method"`, ...) when defined, or `nil` when not. The argument
+      # is not evaluated (it is statically inspected by the runtime),
+      # so the typer does not recurse into it.
+      def type_of_defined(_node)
+        Type::Combinator.union(
+          Type::Combinator.nominal_of("String"),
+          Type::Combinator.constant_of(nil)
+        )
+      end
+
+      # `$1`, `$&`, `$'`, `$+`, `$\`` — the regex back-reference and
+      # numbered-capture globals each carry `String | nil`. They share
+      # the typer because the typing rule is identical regardless of
+      # which back-reference shape Prism emitted.
+      def type_of_string_or_nil(_node)
+        Type::Combinator.union(
+          Type::Combinator.nominal_of("String"),
+          Type::Combinator.constant_of(nil)
+        )
+      end
+
+      # `expr in pattern` — pattern-match predicate. Returns `true`
+      # when the pattern matches, `false` otherwise.
+      def type_of_match_predicate(_node)
+        Type::Combinator.union(
+          Type::Combinator.constant_of(true),
+          Type::Combinator.constant_of(false)
+        )
+      end
+
+      # `expr => pattern` — one-line pattern-match assertion. Raises
+      # `NoMatchingPatternError` on mismatch; on success the expression
+      # itself evaluates to `nil`.
+      def type_of_match_required(_node)
+        Type::Combinator.constant_of(nil)
+      end
+
       # The expression `Foo` evaluates to the *class object* `Foo`, not
       # an instance. From Slice 4 phase 2b on we therefore type a
       # bare-constant reference as `Singleton[Foo]`; method dispatch on
@@ -723,9 +765,38 @@ module Rigor
       def type_of_range(node)
         left_static, left = static_range_endpoint(node.left)
         right_static, right = static_range_endpoint(node.right)
-        return Type::Combinator.nominal_of(Range) unless left_static && right_static
+        return Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?)) if left_static && right_static
 
-        Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?))
+        nominal_range_for_endpoints(node.left, node.right)
+      end
+
+      # Derives `Nominal[Range, [T]]` from the endpoint expression
+      # types when at least one endpoint is statically typeable. The
+      # element parameter is the union of the endpoint types (lifted
+      # from `Constant<v>` to `Nominal<v.class>` so the carrier matches
+      # what `Range#each` would yield). Falls back to bare
+      # `Nominal[Range]` when no endpoint contributes a typable shape.
+      def nominal_range_for_endpoints(left_node, right_node)
+        endpoints = [left_node, right_node].compact.map { |n| range_endpoint_element_type(n) }
+        endpoints.reject! { |t| t.equal?(Type::Combinator.untyped) }
+        return Type::Combinator.nominal_of("Range") if endpoints.empty?
+
+        Type::Combinator.nominal_of("Range", type_args: [Type::Combinator.union(*endpoints)])
+      end
+
+      def range_endpoint_element_type(node)
+        type = type_of(node)
+        case type
+        when Type::Constant
+          value = type.value
+          return Type::Combinator.untyped if value.nil?
+
+          Type::Combinator.nominal_of(value.class.name)
+        when Type::IntegerRange
+          Type::Combinator.nominal_of("Integer")
+        else
+          type
+        end
       end
 
       # v0.0.7 — non-interpolated regex literals lift to
@@ -746,6 +817,7 @@ module Rigor
       def static_range_endpoint(node)
         return [true, nil] if node.nil?
         return [true, node.value] if node.is_a?(Prism::IntegerNode)
+        return [true, node.unescaped] if node.is_a?(Prism::StringNode) && node.respond_to?(:unescaped)
 
         [false, nil]
       end
@@ -805,6 +877,13 @@ module Rigor
         scope.local(node.name) || dynamic_top
       end
 
+      # `it` (Ruby 3.4) — `ItLocalVariableReadNode` carries no `name`
+      # field; the implicit name is always `:it`, matching the binding
+      # `BlockParameterBinder` installs for `Prism::ItParametersNode`.
+      def it_read(_node)
+        scope.local(:it) || dynamic_top
+      end
+
       # Slice 5 phase 1 upgrades array literals to `Tuple[T1..Tn]`
       # when every element is a non-splat value. Splatted entries
       # (`[*xs, 1]`) preserve the Slice 4 phase 2d behavior: we union

data/lib/rigor/inference/method_dispatcher/literal_string_folding.rb

@@ -8,12 +8,21 @@ module Rigor
       # Dispatcher tier that lifts string-composition results into
       # the `literal-string` carrier when every operand is itself
       # literal-bearing. Sits between {ConstantFolding} (which
-      # handles all-Constant cases) and {ShapeDispatch}; runs only
-      # for `String#+` / `String#*` / `String#<<` / `String#concat`
-      # calls whose inputs the ConstantFolding tier could not fold
-      # to a precise `Constant<String>` (e.g. one operand is
-      # `literal-string` rather than `Constant<String>`, or the
-      # multiplication exceeds the constant-fold size cap).
+      # handles all-Constant cases) and {ShapeDispatch}; runs for:
+      #
+      # - `String#+` / `String#*` / `String#<<` / `String#concat`
+      #   on string-typed receivers whose inputs the
+      #   ConstantFolding tier could not fold to a precise
+      #   `Constant<String>` (e.g. one operand is `literal-string`
+      #   rather than `Constant<String>`, or the multiplication
+      #   exceeds the constant-fold size cap).
+      # - `Array#join` on `Tuple[…]` receivers whose every element
+      #   plus the separator argument (when given) is
+      #   literal-bearing.
+      # - `Kernel#format` / `Kernel#sprintf` (any receiver) and
+      #   `String#%` (literal-bearing receiver) when every value
+      #   argument is literal-bearing or a Type::Constant of any
+      #   value.
       #
       # Result rule:
       #
@@ -27,6 +36,12 @@ module Rigor
       #   literal-bearing too.
       # - `*`: receiver MUST be literal-bearing; argument MUST be
       #   integer-typed. The result is `literal-string`.
+      # - `join`: receiver MUST be `Tuple[…]` with every element
+      #   literal-string-compatible; the optional separator
+      #   argument MUST also be literal-string-compatible.
+      #   Result: `literal-string`. Empty `Tuple[]` lifts too —
+      #   `[].join` is the empty string at runtime, which is
+      #   literal-bearing trivially.
       #
       # Other receiver / argument shapes decline so the next tier
       # (ShapeDispatch / FileFolding / RbsDispatch) takes over and
@@ -36,10 +51,16 @@ module Rigor
         module_function
 
         CONCAT_METHODS = %i[+ << concat].freeze
-        private_constant :CONCAT_METHODS
+        FORMAT_METHODS = %i[format sprintf].freeze
+        private_constant :CONCAT_METHODS, :FORMAT_METHODS
+
+        def try_dispatch(receiver:, method_name:, args:, **) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          return fold_array_join(receiver, args) if method_name == :join
+          return fold_format(args) if FORMAT_METHODS.include?(method_name)
 
-        def try_dispatch(receiver:, method_name:, args:, **)
           return nil unless Type::Combinator.literal_string_compatible?(receiver)
+
+          return fold_string_percent(args) if method_name == :%
           return nil unless args.size == 1
 
           if CONCAT_METHODS.include?(method_name)
@@ -62,6 +83,69 @@ module Rigor
           Type::Combinator.literal_string
         end
 
+        # `[lit, lit].join(sep)` — receiver must be a Tuple
+        # whose every element is literal-bearing; separator
+        # (when given) must be literal-bearing too. Multi-arg
+        # forms / `Array#join(*args)` splat shapes don't reach
+        # here because the dispatcher only routes through this
+        # tier when the call resolves to a single named method.
+        def fold_array_join(receiver, args)
+          return nil unless receiver.is_a?(Type::Tuple)
+          return nil unless receiver.elements.all? { |el| Type::Combinator.literal_string_compatible?(el) }
+          return nil unless args.size <= 1
+          return nil if args.size == 1 && !Type::Combinator.literal_string_compatible?(args.first)
+
+          Type::Combinator.literal_string
+        end
+
+        # `format("hello %s", lit)` / `sprintf(...)` — template
+        # plus every value argument must be literal-bearing
+        # ({Type::Combinator.literal_string_compatible?}) or a
+        # `Type::Constant` of any value (Constants are always
+        # provably literal). The template arg specifically must
+        # be literal-bearing — a Constant<Integer> first arg
+        # would not be a valid format template, so the
+        # `Type::Constant` allowance applies only to subsequent
+        # value args.
+        def fold_format(args)
+          return nil if args.empty?
+          return nil unless Type::Combinator.literal_string_compatible?(args.first)
+          return nil unless args.drop(1).all? { |arg| literal_or_constant?(arg) }
+
+          Type::Combinator.literal_string
+        end
+
+        # `"foo %s" % "x"` / `"foo %s" % ["x", "y"]` — receiver
+        # is the template (already verified literal-bearing by
+        # the caller); arg is either:
+        #
+        # - a single literal-bearing string / Constant value, or
+        # - a Tuple whose every element is literal-bearing or a
+        #   Constant.
+        #
+        # Hash-form `%` (e.g. `"%{name}" % {name: "x"}`) is not
+        # yet folded — the analyzer's HashShape carrier could
+        # support this, but the v0.0.x catalogue declines and
+        # widens to Nominal[String].
+        def fold_string_percent(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          if arg.is_a?(Type::Tuple)
+            return nil unless arg.elements.all? { |el| literal_or_constant?(el) }
+
+            return Type::Combinator.literal_string
+          end
+
+          return nil unless literal_or_constant?(arg)
+
+          Type::Combinator.literal_string
+        end
+
+        def literal_or_constant?(type)
+          Type::Combinator.literal_string_compatible?(type) || type.is_a?(Type::Constant)
+        end
+
         def integer_typed?(type)
           case type
           when Type::Constant then type.value.is_a?(Integer)
@@ -80,7 +164,9 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
         end
 
-        private_class_method :fold_concat, :fold_repeat, :integer_typed?
+        private_class_method :fold_concat, :fold_repeat, :fold_array_join,
+                             :fold_format, :fold_string_percent,
+                             :literal_or_constant?, :integer_typed?
       end
     end
   end

data/lib/rigor/inference/method_dispatcher/rbs_dispatch.rb

@@ -243,7 +243,13 @@ module Rigor
 
           # rubocop:disable Metrics/ParameterLists
           def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:)
-            override = RbsExtended.read_return_type_override(method_definition)
+            # Slice 4b-3 (ADR-7 § "Slice 4-A/4-B") — read the
+            # return-type override through the merger so future
+            # plugin / `:rbs_extended` bundles that also assert a
+            # `return_type` slot at this call site compose with
+            # the RBS::Extended directive instead of silently
+            # racing it.
+            override = merged_return_type(method_definition)
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
@@ -274,6 +280,20 @@ module Rigor
           end
           # rubocop:enable Metrics/ParameterLists
 
+          # ADR-7 § "Slice 4-A/4-B" — folds the
+          # `RBS::Extended` `return:` directive (and any
+          # other `return_type`-bearing contribution future
+          # slices add at this call site) through the merger
+          # before consuming. Returns the merged return type
+          # or nil when no contribution overrides the
+          # RBS-declared return.
+          def merged_return_type(method_definition)
+            contribution = RbsExtended.read_flow_contribution(method_definition)
+            return nil if contribution.nil?
+
+            Rigor::FlowContribution::Merger.merge([contribution]).return_type
+          end
+
           # When a block type is supplied, locate the method-level
           # type parameter that the selected overload's block return
           # type references and bind it to `block_type`. The

data/lib/rigor/inference/multi_target_binder.rb

@@ -131,6 +131,8 @@ module Rigor
         end
 
         def bind_rest_target(splat_node, type, bindings)
+          return unless splat_node.is_a?(Prism::SplatNode)
+
           expression = splat_node.expression
           case expression
           when Prism::LocalVariableTargetNode, Prism::RequiredParameterNode

data/lib/rigor/inference/narrowing.rb

@@ -293,6 +293,29 @@ module Rigor
         end
       end
 
+      # ADR-7 § "Slice 4-A" — public Fact-shaped narrowing
+      # entry. Distinguishes a `Nominal[<class>]`-typed Fact
+      # (uses `narrow_class` / `narrow_not_class` for
+      # hierarchy-aware narrowing) from a refinement-shaped
+      # Fact (refined types, IntegerRange, Difference, …).
+      # The implementation lives next to its sibling helpers
+      # `narrow_class` and `narrow_not_refinement`; consumers
+      # outside `Narrowing` (today: `StatementEvaluator`'s
+      # post-return assertion path) reach for it via
+      # `Rigor::Inference::Narrowing.narrow_for_fact`.
+      def narrow_for_fact(current, fact, environment)
+        if fact.type.is_a?(Type::Nominal) && fact.type.type_args.empty?
+          class_name = fact.type.class_name
+          return narrow_not_class(current, class_name, exact: false, environment: environment) if fact.negative?
+
+          return narrow_class(current, class_name, exact: false, environment: environment)
+        end
+
+        return narrow_not_refinement(current, fact.type) if fact.negative?
+
+        fact.type
+      end
+
       # Public predicate analyser. Returns `[truthy_scope, falsey_scope]`,
       # always; when no narrowing rule matches the predicate node both
       # entries are the receiver scope unchanged.
@@ -352,7 +375,7 @@ module Rigor
       # the predicate shape is recognised, or `nil` to signal "no
       # narrowing" so the public surface can fall back to the entry
       # scope.
-      def analyse(node, scope)
+      def analyse(node, scope) # rubocop:disable Metrics/CyclomaticComplexity
         case node
         when Prism::ParenthesesNode
           analyse_parentheses(node, scope)
@@ -366,6 +389,8 @@ module Rigor
           analyse_and(node, scope)
         when Prism::OrNode
           analyse_or(node, scope)
+        when Prism::MatchWriteNode
+          analyse_match_write(node, scope)
         end
       end
 
@@ -712,6 +737,29 @@ module Rigor
           ]
         end
 
+        # `if /(?<x>...)/ =~ str` — Prism wraps the `=~` call in a
+        # `MatchWriteNode` listing the named-capture targets. The
+        # parent `eval_match_write` has already bound each target
+        # to `String | nil`; in the truthy branch (the regex
+        # matched) every named capture is guaranteed `String`,
+        # and in the falsey branch (no match) every capture is
+        # `nil`. Subtract the dead half on each edge so callers
+        # like `year.upcase` inside the truthy branch no longer
+        # fire `possible-nil-receiver`.
+        def analyse_match_write(node, scope)
+          string_t = Type::Combinator.nominal_of("String")
+          nil_t = Type::Combinator.constant_of(nil)
+          truthy = scope
+          falsey = scope
+          node.targets.each do |target|
+            next unless target.is_a?(Prism::LocalVariableTargetNode)
+
+            truthy = truthy.with_local(target.name, string_t)
+            falsey = falsey.with_local(target.name, nil_t)
+          end
+          [truthy, falsey]
+        end
+
         # Recognised CallNode predicates:
         # - `recv.nil?` (Slice 6 phase 1, no args, no block)
         # - unary `!recv` (`name == :!`, no args, no block)
@@ -734,32 +782,7 @@ module Rigor
           # `rigor:v1:predicate-if-true` / `predicate-if-false`
           # annotations, apply them to narrow the corresponding
           # local-variable arguments on each edge.
-          predicate_result = analyse_rbs_extended_predicate(node, scope)
-          assert_result = analyse_rbs_extended_assert_if(node, scope)
-          merge_extended_results(predicate_result, assert_result, scope)
-        end
-
-        # Combines two `[truthy_scope, falsey_scope]` pair
-        # results from sibling RBS::Extended analysers
-        # (`predicate-if-*` and `assert-if-*`). When only one
-        # side fires, return it directly; when both fire the
-        # right side's per-local deltas are applied on top of
-        # the left side's edges so the rules compose.
-        def merge_extended_results(left, right, base_scope)
-          return left if right.nil?
-          return right if left.nil?
-
-          [
-            merge_scope_pair(left[0], right[0], base_scope),
-            merge_scope_pair(left[1], right[1], base_scope)
-          ]
-        end
-
-        def merge_scope_pair(left_scope, right_scope, base_scope)
-          right_scope.locals.reduce(left_scope) do |acc, (name, type)|
-            base_type = base_scope.local(name)
-            type.equal?(base_type) ? acc : acc.with_local(name, type)
-          end
+          analyse_rbs_extended_contribution(node, scope)
         end
 
         ZERO_CLASS_PREDICATES = %i[positive? negative? zero? nonzero?].freeze
@@ -1187,113 +1210,83 @@ module Rigor
           node
         end
 
-        # Slice 7 phase 15 — RBS::Extended predicate-effect
-        # analyser. Resolves the called method through the
-        # RBS environment, reads any `rigor:v1:predicate-if-*`
-        # annotations, and applies them to the call's
-        # local-variable arguments.
+        # Slice 4b-1 (ADR-7 § "Slice 4-A/4-B") — single-point
+        # RBS::Extended contribution analyser. Replaces the
+        # earlier sibling pair (`analyse_rbs_extended_predicate`
+        # + `analyse_rbs_extended_assert_if`) with one path that
+        # routes through `RbsExtended.read_flow_contribution` and
+        # `Rigor::FlowContribution::Merger.merge`. The bundle's
+        # `truthy_facts` slot already includes both the
+        # `predicate-if-true` and `assert-if-true` Facts (slice
+        # 4a routing closed the v0.0.9 imperfection); the
+        # `falsey_facts` slot mirrors that. The merger composes
+        # any future plugin contribution at the same site
+        # alongside the RBS::Extended bundle without changing
+        # this analyser.
         #
-        # Conservative envelope:
+        # Conservative envelope (carried over from the previous
+        # implementation):
         # - Receiver type must be `Type::Nominal`,
         #   `Type::Singleton`, or `Type::Constant`.
         # - The method must be present in the loader.
-        # - For each predicate effect, the corresponding
-        #   positional argument (matched by parameter name in
-        #   the selected overload) MUST be a
-        #   `Prism::LocalVariableReadNode` for narrowing to
-        #   apply.
-        # - When the target is `self`, narrowing applies to
-        #   the receiver — but the engine does not yet narrow
-        #   `self` itself (Slice A-engine self-typing is
-        #   read-only), so `self`-targeted effects are
-        #   accepted by the parser but currently produce no
+        # - For each fact, the corresponding positional
+        #   argument (matched by parameter name in the selected
+        #   overload) MUST be a `Prism::LocalVariableReadNode`
+        #   for narrowing to apply.
+        # - When the target is `self`, narrowing applies to the
+        #   receiver — but the engine does not yet narrow
+        #   `self` itself, so `self`-targeted facts are
+        #   accepted by the merger but currently produce no
         #   scope edits.
-        def analyse_rbs_extended_predicate(node, scope)
+        def analyse_rbs_extended_contribution(node, scope)
           method_def = resolve_rbs_extended_method(node, scope)
           return nil if method_def.nil?
 
-          effects = RbsExtended.read_predicate_effects(method_def)
-          return nil if effects.empty?
-
-          truthy_scope = scope
-          falsey_scope = scope
-          effects.each do |effect|
-            truthy_scope, falsey_scope =
-              apply_predicate_effect(effect, node, scope, truthy_scope, falsey_scope, method_def)
-          end
-          [truthy_scope, falsey_scope]
-        end
+          contribution = RbsExtended.read_flow_contribution(method_def)
+          return nil if contribution.nil?
 
-        # v0.0.2 — `assert-if-true` / `assert-if-false`. Reads
-        # the conditional assertion effects off the called
-        # method and narrows the matching argument on the
-        # corresponding edge. The unconditional `assert`
-        # variant is NOT applied here; `StatementEvaluator`
-        # applies it directly to the post-call scope.
-        def analyse_rbs_extended_assert_if(node, scope)
-          method_def = resolve_rbs_extended_method(node, scope)
-          return nil if method_def.nil?
+          result = Rigor::FlowContribution::Merger.merge([contribution])
+          truthy_facts = result.truthy_facts
+          falsey_facts = result.falsey_facts
+          return nil if truthy_facts.empty? && falsey_facts.empty?
 
-          effects = RbsExtended.read_assert_effects(method_def).reject(&:always?)
-          return nil if effects.empty?
+          apply_facts_to_scope_pair(node, scope, truthy_facts, falsey_facts, method_def)
+        end
 
-          truthy_scope = scope
-          falsey_scope = scope
-          effects.each do |effect|
-            truthy_scope, falsey_scope =
-              apply_assert_if_effect(effect, node, scope, truthy_scope, falsey_scope, method_def)
+        def apply_facts_to_scope_pair(call_node, entry_scope, truthy_facts, falsey_facts, method_def)
+          truthy_scope = entry_scope
+          falsey_scope = entry_scope
+          truthy_facts.each do |fact|
+            truthy_scope = apply_fact_to_scope(fact, call_node, entry_scope, truthy_scope, method_def)
+          end
+          falsey_facts.each do |fact|
+            falsey_scope = apply_fact_to_scope(fact, call_node, entry_scope, falsey_scope, method_def)
           end
           [truthy_scope, falsey_scope]
         end
 
-        # rubocop:disable Metrics/ParameterLists
-        def apply_assert_if_effect(effect, call_node, entry_scope, truthy_scope, falsey_scope, method_def)
-          target_node = effect_target_node(effect, call_node, method_def)
-          return [truthy_scope, falsey_scope] unless target_node.is_a?(Prism::LocalVariableReadNode)
+        def apply_fact_to_scope(fact, call_node, entry_scope, target_scope, method_def)
+          target_node = fact_target_node(fact, call_node, method_def)
+          return target_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
 
           local_name = target_node.name
           current = entry_scope.local(local_name)
-          return [truthy_scope, falsey_scope] if current.nil?
+          return target_scope if current.nil?
 
-          narrowed = narrow_for_effect(current, effect, entry_scope.environment)
-          if effect.if_truthy_return?
-            [truthy_scope.with_local(local_name, narrowed), falsey_scope]
-          else
-            [truthy_scope, falsey_scope.with_local(local_name, narrowed)]
-          end
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        # v0.0.2 #3 — resolves an effect's target node. For
-        # `target: <param>` we look up the matching positional
-        # argument; for `target: self` we use the call's
-        # receiver. In both cases the caller still requires a
-        # `Prism::LocalVariableReadNode` for narrowing to
-        # actually fire (the engine's narrowing surface only
-        # rebinds locals).
-        def effect_target_node(effect, call_node, method_def)
-          if effect.target_kind == :self
-            call_node.receiver
-          else
-            lookup_positional_arg(call_node, method_def, effect.target_name)
-          end
+          narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+          target_scope.with_local(local_name, narrowed)
         end
 
-        # v0.0.2 — selects `narrow_class` (positive) or
-        # `narrow_not_class` (negative `~T` form) based on
-        # the effect's `negative?` flag. Shared between
-        # predicate-if-* and assert-if-* application paths.
-        def narrow_for_effect(current, effect, environment)
-          if effect.respond_to?(:refinement?) && effect.refinement?
-            return narrow_not_refinement(current, effect.refinement_type) if effect.negative?
-
-            return effect.refinement_type
-          end
-
-          if effect.negative?
-            narrow_not_class(current, effect.class_name, exact: false, environment: environment)
+        # Resolves a Fact's target node. Mirrors the earlier
+        # `effect_target_node` helper but reads from the
+        # canonical Fact carrier; `:self` routes to the call
+        # receiver, otherwise we look up the matching
+        # positional argument by parameter name.
+        def fact_target_node(fact, call_node, method_def)
+          if fact.target_kind == :self
+            call_node.receiver
           else
-            narrow_class(current, effect.class_name, exact: false, environment: environment)
+            lookup_positional_arg(call_node, method_def, fact.target_name)
           end
         end
 
@@ -1332,24 +1325,6 @@ module Rigor
           nil
         end
 
-        # rubocop:disable Metrics/ParameterLists
-        def apply_predicate_effect(effect, call_node, entry_scope, truthy_scope, falsey_scope, method_def)
-          target_node = effect_target_node(effect, call_node, method_def)
-          return [truthy_scope, falsey_scope] unless target_node.is_a?(Prism::LocalVariableReadNode)
-
-          local_name = target_node.name
-          current = entry_scope.local(local_name)
-          return [truthy_scope, falsey_scope] if current.nil?
-
-          narrowed = narrow_for_effect(current, effect, entry_scope.environment)
-          if effect.truthy_only?
-            [truthy_scope.with_local(local_name, narrowed), falsey_scope]
-          else
-            [truthy_scope, falsey_scope.with_local(local_name, narrowed)]
-          end
-        end
-        # rubocop:enable Metrics/ParameterLists
-
         # Maps the effect's target parameter name to the call
         # site argument by inspecting the selected overload's
         # required-positional parameter list. Returns the Prism