rigortype 0.0.8 → 0.1.0

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # 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 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:
+      #
+      # - `+`, `<<`, `concat`: receiver and argument MUST both be
+      #   `Type::Combinator.literal_string_compatible?`. The result
+      #   is `literal-string`. `<<` and `concat` mutate the
+      #   receiver at runtime; the analyzer does not track that
+      #   mutation against the local's binding, but the call's
+      #   *return value* is the receiver itself, and the receiver
+      #   stays literal-bearing because every appended slice was
+      #   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
+      # the call site widens to the RBS-declared `Nominal[String]`
+      # as before.
+      module LiteralStringFolding
+        module_function
+
+        CONCAT_METHODS = %i[+ << concat].freeze
+        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)
+
+          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)
+            fold_concat(args.first)
+          elsif method_name == :*
+            fold_repeat(args.first)
+          end
+        end
+
+        def fold_concat(arg_type)
+          return nil unless Type::Combinator.literal_string_compatible?(arg_type)
+
+          Type::Combinator.literal_string
+        end
+
+        def fold_repeat(arg_type)
+          return nil unless integer_typed?(arg_type)
+          return nil if known_negative_integer?(arg_type)
+
+          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)
+          when Type::Nominal then type.class_name == "Integer"
+          when Type::IntegerRange then true
+          else false
+          end
+        end
+
+        # `String#*` raises ArgumentError on a negative multiplier, so a
+        # `Constant<-1>` argument is not a valid lift target. Decline so
+        # the call site keeps the existing nil-result behaviour rather
+        # than promising a `literal-string` value that could never
+        # exist at runtime.
+        def known_negative_integer?(type)
+          type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
+        end
+
+        private_class_method :fold_concat, :fold_repeat, :fold_array_join,
+                             :fold_format, :fold_string_percent,
+                             :literal_or_constant?, :integer_typed?
+      end
+    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/method_dispatcher.rb

@@ -3,6 +3,7 @@
 require_relative "../reflection"
 require_relative "../type"
 require_relative "method_dispatcher/constant_folding"
+require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
@@ -101,6 +102,7 @@ module Rigor
         return meta_result if meta_result
 
         ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          LiteralStringFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||

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
 
@@ -539,26 +564,41 @@ module Rigor
         # downstream narrowing knows the refinement subset is
         # excluded.
         #
-        # The result is sound but imprecise: without a
-        # complementary carrier (e.g. `mixed-case-string` for
-        # `~lowercase-string`) we cannot enumerate the surviving
-        # values. Difference is the carrier-of-last-resort, and
-        # the existing `Type::Difference` consumers already
-        # treat it correctly.
+        # v0.0.9 — when the predicate has a registered
+        # complement (see {Type::Refined::COMPLEMENT_PAIRS}) and
+        # the part is exactly the refinement's base, the
+        # narrowing returns `Refined[base, complement_predicate]`
+        # instead of `Difference[base, refined]`. This is the
+        # `~T` symmetry the spec promises: `~lowercase-string`
+        # narrows `String` to `non-lowercase-string` rather than
+        # `Difference[String, lowercase-string]`.
+        #
+        # Predicates without a registered complement still fall
+        # back to the imprecise but sound `Difference[part,
+        # refined]` carrier so behaviour is unchanged for
+        # untouched call sites.
         def complement_refined(current_type, refined)
-          base = refined.base
+          complement = registered_complement_for(refined)
           parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
+          survivors = parts.filter_map { |part| complement_refined_part(part, refined, complement) }
+          return current_type if survivors.empty?
+
+          Type::Combinator.union(*survivors)
+        end
 
-          survivors = parts.map do |part|
-            next nil if part == refined
-            next part if base_disjoint?(base, part)
+        def complement_refined_part(part, refined, complement)
+          return nil if part == refined
+          return part if base_disjoint?(refined.base, part)
+          return complement if complement && part == refined.base
 
-            Type::Combinator.difference(part, refined)
-          end.compact
+          Type::Combinator.difference(part, refined)
+        end
 
-          return current_type if survivors.empty?
+        def registered_complement_for(refined)
+          complement_id = refined.complement_predicate_id
+          return nil if complement_id.nil?
 
-          Type::Combinator.union(*survivors)
+          Type::Combinator.refined(refined.base, complement_id)
         end
 
         def falsey_value?(value)
@@ -697,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)
@@ -719,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
@@ -1172,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?
+          contribution = RbsExtended.read_flow_contribution(method_def)
+          return nil if contribution.nil?
 
-          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
+          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?
 
-        # 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?
-
-          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
 
@@ -1317,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