rigortype 0.1.19 → 0.2.0

data/lib/rigor/inference/statement_evaluator.rb

@@ -6,8 +6,10 @@ require_relative "../reflection"
 require_relative "../type"
 require_relative "../analysis/fact_store"
 require_relative "../source/node_walker"
+require_relative "../source/constant_path"
 require_relative "block_parameter_binder"
 require_relative "body_fixpoint"
+require_relative "struct_fold_safety"
 require_relative "closure_escape_analyzer"
 require_relative "indexed_narrowing"
 require_relative "method_dispatcher"
@@ -100,6 +102,7 @@ module Rigor
         Prism::CallNode => :eval_call,
         Prism::BlockNode => :eval_block,
         Prism::ReturnNode => :eval_return,
+        Prism::BreakNode => :eval_break,
         Prism::MatchWriteNode => :eval_match_write
       }.freeze
       private_constant :HANDLERS
@@ -115,6 +118,19 @@ module Rigor
       RETURN_SINK_KEY = :rigor_return_sink
       private_constant :RETURN_SINK_KEY
 
+      # Thread-local sink (an Array of `[BreakNode, Scope]`) collecting the
+      # scope at each `break` reached while evaluating a loop body, so
+      # `eval_loop` / `eval_for` can join a `break`-path binding (`flag = true;
+      # break`) into the loop continuation that the fall-through would
+      # otherwise drop. Stacks like the return sink: a nested loop installs its
+      # own sink, restored on exit, so an inner loop's break does not leak to
+      # the outer one. A `break` inside a block / nested loop targets that
+      # inner construct, not the lexical loop — filtered out by the
+      # directly-targeting break set, see {#directly_targeting_breaks}.
+      # See docs/notes/20260615-loop-break-binding-propagation-design.md.
+      BREAK_SINK_KEY = :rigor_break_sink
+      private_constant :BREAK_SINK_KEY
+
       # Lexical class frame: the `name:` field is the qualified class
       # name as it would render in Ruby (e.g., `"Foo::Bar"`); the
       # `singleton:` field is `true` for `class << self` frames so
@@ -365,9 +381,7 @@ module Rigor
       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
+      # idiom. 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.
@@ -480,10 +494,24 @@ module Rigor
         # then-branch unconditionally exits (return / next /
         # break / raise) and there is no else, the post-scope
         # is the falsey edge of the predicate (subsequent
-        # statements observe the predicate-was-false world).
+        # statements observe the predicate-was-false world). The
+        # then-body is the *skipped* path, so the bare narrowing
+        # (no body assignments) is the correct continuation.
         return [Type::Combinator.union(then_type, else_type), falsey_scope] \
           if branch_terminates?(node.statements, then_type) && node.subsequent.nil?
-        return [Type::Combinator.union(then_type, else_type), truthy_scope] \
+        # Symmetric case: the else / elsif-chain (`node.subsequent`)
+        # unconditionally exits, so the only surviving path is the
+        # then-branch that RAN. The continuation must therefore carry
+        # `then_scope` — the predicate-truthy narrowing PLUS the
+        # then-body's assignments — not the bare `truthy_scope`.
+        # Returning `truthy_scope` drops every local the then-body
+        # bound, leaving it unbound for any enclosing merge to
+        # spuriously nil-inject: e.g. the inner `elsif … else raise`
+        # of `if a then x=… elsif b then x=… else raise end` would
+        # return with `x` unbound, and the outer if's join would then
+        # read `x` as `… | nil` and fire a false `possible-nil-receiver`
+        # (liquid v5.x sweep, Event 3).
+        return [Type::Combinator.union(then_type, else_type), then_scope] \
           if branch_terminates?(node.subsequent, else_type) && node.statements
 
         [
@@ -518,10 +546,17 @@ module Rigor
         else_type, else_scope = eval_branch_or_nil(node.else_clause, truthy_scope)
         # Slice 7 phase 14 — same early-return narrowing as
         # `if`: when the body unconditionally exits and there
-        # is no else, the post-scope is the truthy edge.
+        # is no else, the post-scope is the truthy edge (the body
+        # is the skipped path, so the bare narrowing is correct).
         return [Type::Combinator.union(then_type, else_type), truthy_scope] \
           if branch_terminates?(node.statements, then_type) && node.else_clause.nil?
-        return [Type::Combinator.union(then_type, else_type), falsey_scope] \
+        # Symmetric to the `if` else-exits fix: when the else-clause
+        # exits, the surviving path is the unless-body that RAN, so the
+        # continuation carries `then_scope` (the predicate-falsey
+        # narrowing PLUS the body's assignments), not the bare
+        # `falsey_scope` — otherwise body-bound locals are dropped and
+        # an enclosing merge nil-injects them.
+        return [Type::Combinator.union(then_type, else_type), then_scope] \
           if branch_terminates?(node.else_clause, else_type) && node.statements
 
         [
@@ -900,7 +935,11 @@ module Rigor
         # widens `buf`'s Tuple), body-introduced locals' nil-injection, and
         # the loop value itself. The fixpoint then OVERLAYS only the
         # rebound-local bindings it corrects.
-        _body_type, body_scope = sub_eval(node.statements, post_pred)
+        #
+        # The pass runs under a break sink so a `break`-path binding
+        # (`flag = true; break`) the fall-through `body_scope` drops is
+        # collected for the continuation join below.
+        break_targets, break_sink, body_scope = capture_loop_body_breaks(node.statements, post_pred)
         base_scope = join_with_nil_injection(post_pred, body_scope)
 
         rebound, body_first = loop_body_local_writes(node.statements, post_pred)
@@ -915,36 +954,41 @@ module Rigor
           return [Type::Combinator.constant_of(nil), narrow_loop_exit_edge(node, fast)]
         end
 
+        post_loop = converged_loop_scope(node, post_pred, base_scope, names, body_first)
+        # Recover `break`-path bindings the fall-through dropped (`flag = true;
+        # break` -> `flag` is `false | true`, not the stale `false`).
+        post_loop = join_break_scopes(post_loop, break_sink, break_targets, names)
+        post_loop = narrow_loop_exit_edge(node, post_loop)
+        [Type::Combinator.constant_of(nil), post_loop]
+      end
+
+      # The continuation scope for a loop whose body rebinds locals: the
+      # ADR-56 slice-B rebind fixpoint overlaid on `base_scope`, then the
+      # slice-C receiver-content writeback.
+      def converged_loop_scope(node, post_pred, base_scope, names, body_first)
         # ADR-56 slice B — loop-body fixpoint. The body runs 0..N times and
         # may compound (`d *= 2`), so the historical single body pass joined
         # with the pre-loop scope kept stale folded constants
         # (`d = 1; while …; d *= 2; end` → `1 | 2`, never reaching `4, 8`).
-        # Fold each body-written local's continuation binding through the
-        # same capped fixpoint slice A uses for non-escaping block captures.
-        #
-        # Seed: a pre-existing local seeds with its post-predicate binding;
-        # a local FIRST assigned inside the body seeds with `nil` so the
-        # 0-iteration path (the body may never run) degrades it to
-        # `T | nil`, matching the historical nil-injection treatment.
+        # Fold each body-written local's continuation binding through the same
+        # capped fixpoint slice A uses for non-escaping block captures. Seed:
+        # a pre-existing local seeds with its post-predicate binding; a local
+        # FIRST assigned inside the body seeds with `nil` so the 0-iteration
+        # path degrades it to `T | nil`, matching the nil-injection treatment.
         result = loop_rebind_fixpoint(node, post_pred, names, body_first)
         # Display-path re-record: the fixpoint's body re-evaluations fire
         # `on_enter` with the cap-N INTERMEDIATE assumptions, so the
         # last-visit-wins scope index would annotate loop-body lines with
-        # stale pre-convergence constants. One extra pass from the
-        # converged bindings (result discarded) re-records the body's
-        # entry scopes post-writeback.
+        # stale pre-convergence constants. One extra pass from the converged
+        # bindings (result discarded) re-records the body's entry scopes.
         record_converged_loop_body(node, post_pred, result, names, body_first)
         post_loop = result.reduce(base_scope) { |acc, (name, type)| acc.with_local(name, type) }
-        # ADR-56 slice C — loop-body receiver-content element-type join. A
-        # loop that content-mutates a collection (`acc << n`) keeps only the
-        # seed's element types after the single-pass widen (B1 unsoundness:
-        # `acc = [0]; while …; acc << n; end` → `Array[0]`, runtime
-        # `[0, n, …]`). Join the appended/stored types into the continuation
-        # collection. Pre-state is read from `post_loop` so a local both
-        # rebound and content-mutated composes.
-        post_loop = loop_content_writeback(node.statements, post_loop)
-        post_loop = narrow_loop_exit_edge(node, post_loop)
-        [Type::Combinator.constant_of(nil), post_loop]
+        # ADR-56 slice C — loop-body receiver-content element-type join. A loop
+        # that content-mutates a collection (`acc << n`) keeps only the seed's
+        # element types after the single-pass widen; join the appended/stored
+        # types into the continuation collection (pre-state read from
+        # `post_loop` so a local both rebound and content-mutated composes).
+        loop_content_writeback(node.statements, post_loop)
       end
 
       # Item 4 — loop-exit predicate narrowing. A `while pred` / `until pred`
@@ -983,6 +1027,87 @@ module Rigor
         found
       end
 
+      # A `break` inside one of these nested constructs targets the inner
+      # construct (an inner loop, a block's method, a nested def), NOT the
+      # lexical loop — so the directly-targeting break scan does not descend
+      # into them.
+      BREAK_BOUNDARY_NODES = [
+        Prism::ForNode, Prism::WhileNode, Prism::UntilNode,
+        Prism::BlockNode, Prism::LambdaNode, Prism::DefNode,
+        Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+      ].freeze
+      private_constant :BREAK_BOUNDARY_NODES
+
+      # The `BreakNode`s that lexically target THIS loop — reachable from the
+      # body without crossing a nested loop / block / def boundary. An
+      # identity-keyed Hash used as a membership set to filter the collected
+      # break scopes (the thread-local sink also collects breaks from nested
+      # blocks that did not install their own sink).
+      def directly_targeting_breaks(statements)
+        found = {}.compare_by_identity
+        collect_direct_breaks(statements, found)
+        found
+      end
+
+      def collect_direct_breaks(node, found)
+        return if node.nil?
+
+        found[node] = true if node.is_a?(Prism::BreakNode)
+        node.compact_child_nodes.each do |child|
+          next if BREAK_BOUNDARY_NODES.any? { |klass| child.is_a?(klass) }
+
+          collect_direct_breaks(child, found)
+        end
+      end
+
+      # Installs a fresh thread-local break sink around `yield` (a loop-body
+      # evaluation), returning `[collected, yield_result]`. Stacks: the
+      # previous sink is restored on exit so a nested loop's breaks do not
+      # leak to the enclosing loop.
+      def collect_break_scopes
+        previous = Thread.current[BREAK_SINK_KEY]
+        sink = []
+        Thread.current[BREAK_SINK_KEY] = sink
+        begin
+          result = yield
+        ensure
+          Thread.current[BREAK_SINK_KEY] = previous
+        end
+        [sink, result]
+      end
+
+      # Runs a loop body's single pass under a break sink. Returns the
+      # directly-targeting break set, the collected break scopes, and the
+      # fall-through body scope — the three inputs the continuation's
+      # {#join_break_scopes} needs. Shared by `eval_loop` and `eval_for`.
+      def capture_loop_body_breaks(statements, entry)
+        targets = directly_targeting_breaks(statements)
+        sink, (_type, body_scope) = collect_break_scopes { sub_eval(statements, entry) }
+        [targets, sink, body_scope]
+      end
+
+      # Joins each directly-targeting break's body-written local bindings into
+      # the loop continuation, so a `break`-path binding the fall-through
+      # dropped is recovered (`flag = true; break` -> `flag` becomes `false |
+      # true`). Only loop-body-written names are joined — an unchanged local
+      # unions to itself; a break-only-written local is already present via the
+      # fixpoint / nil-injection seed, so the union reflects its break value.
+      def join_break_scopes(continuation, sink, targeting, names)
+        return continuation if sink.empty? || names.empty?
+
+        breaks = sink.select { |(node, _scope)| targeting.key?(node) }
+        breaks.reduce(continuation) do |cont, (_node, break_scope)|
+          names.reduce(cont) do |acc, name|
+            break_value = break_scope.local(name)
+            next acc if break_value.nil?
+
+            current = acc.local(name)
+            joined = current ? Type::Combinator.union(current, break_value) : break_value
+            acc.with_local(name, joined)
+          end
+        end
+      end
+
       # Joins loop-body content mutations into the continuation collection
       # bindings. The mutator arguments are typed against `post_loop`, whose
       # locals already carry the loop-body fixpoint widening (so an
@@ -1107,11 +1232,19 @@ module Rigor
         element_type = for_iteration_element_type(coll_type)
         body_entry = bind_for_index(node.index, element_type, post_coll)
 
-        body_scope = node.statements ? sub_eval(node.statements, body_entry).last : body_entry
-        [
-          Type::Combinator.constant_of(nil),
-          join_with_nil_injection(post_coll, body_scope)
-        ]
+        if node.statements.nil?
+          return [Type::Combinator.constant_of(nil), join_with_nil_injection(post_coll, body_entry)]
+        end
+
+        # Run the body pass under a break sink so a `break`-path binding the
+        # fall-through drops is recovered into the continuation (the `for`
+        # sibling of `eval_loop`'s break join; `for` has no fixpoint, so the
+        # single-pass join is the only continuation).
+        break_targets, break_sink, body_scope = capture_loop_body_breaks(node.statements, body_entry)
+        continuation = join_with_nil_injection(post_coll, body_scope)
+        pre_existing, body_first = loop_body_local_writes(node.statements, post_coll)
+        continuation = join_break_scopes(continuation, break_sink, break_targets, pre_existing + body_first)
+        [Type::Combinator.constant_of(nil), continuation]
       end
 
       # `for x in coll` is semantically `coll.each { |x| ... }`. We
@@ -1278,7 +1411,7 @@ module Rigor
       # (`Constant[nil]` for an empty body); we discard the body's
       # post-scope.
       def eval_class_or_module(node)
-        name = qualified_name_for(node.constant_path)
+        name = Source::ConstantPath.qualified_name(node.constant_path)
         new_context = @class_context + [ClassFrame.new(name: name, singleton: false)]
         body_type, _body_scope = eval_class_body(node, new_context)
         [body_type, scope]
@@ -1404,21 +1537,15 @@ module Rigor
         # parameter (not for every self-call), and sound — only loses
         # precision on the floored argument.
         post_scope = widen_callee_escaped_argument_captures(node, 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.
+        # Same always-safe rationale as `widen_after_call` above —
+        # propagates outer-scope local / ivar widening from block body
+        # mutations (`items.each { |x| arr << x }`).
         post_scope = MutationWidening.widen_after_block(call_node: node, outer_scope: post_scope)
-        # ADR-56 slice C — receiver-content element-type join. The widening
-        # above forgets a content-mutated collection's literal arity but
-        # keeps only the seed's element types (the B1 unsound under-
-        # approximation for a non-empty seed). Join the appended / stored
-        # element / key / value types into the continuation collection's
-        # parameter so `out = [0]; arr.each { |x| out << x }` types
-        # `Array[0 | Integer]`, not `Array[0]`. Always sound — only widens.
+        # ADR-56 slice C — receiver-content element-type join. Joins
+        # appended / stored element / key / value types into the
+        # continuation collection so `out = [0]; arr.each { |x| out << x }`
+        # types `Array[0 | Integer]`, not `Array[0]`. Same always-safe
+        # rationale (only widens).
         post_scope = content_writeback_block_captures(node, post_scope)
         # Indexed-collection narrowing — drop any
         # `receiver[key] ||= default` narrowing the analyzer
@@ -1609,7 +1736,7 @@ module Rigor
         args = matcher.arguments&.arguments || []
         return nil unless args.size == 1
 
-        class_name = constant_node_name(args.first)
+        class_name = Source::ConstantPath.qualified_name_or_nil(args.first)
         return nil if class_name.nil?
 
         { local: local_name, kind: :class, class_name: class_name, exact: exact }
@@ -1665,35 +1792,6 @@ module Rigor
         matcher.arguments.nil? || matcher.arguments.arguments.empty?
       end
 
-      # Decodes a `Prism::ConstantReadNode` /
-      # `Prism::ConstantPathNode` into a colon-joined class
-      # name string, or returns nil for any other node
-      # shape. Mirrors the conservative envelope used by the
-      # `is_a?` / `kind_of?` predicate narrower.
-      def constant_node_name(node)
-        case node
-        when Prism::ConstantReadNode
-          node.name.to_s
-        when Prism::ConstantPathNode
-          flatten_constant_path(node)
-        end
-      end
-
-      def flatten_constant_path(node)
-        parts = []
-        cursor = node
-        while cursor.is_a?(Prism::ConstantPathNode)
-          parts.unshift(cursor.name.to_s)
-          cursor = cursor.parent
-        end
-        case cursor
-        when Prism::ConstantReadNode then parts.unshift(cursor.name.to_s)
-        when nil then nil # ::Foo absolute root — preserve as-is
-        else return nil
-        end
-        parts.join("::")
-      end
-
       # Slice 4b-2 (ADR-7 § "Slice 4-A/4-B") — applies the
       # post-return facts the merger produces for an
       # `RBS::Extended`-annotated call. Reads through
@@ -1702,9 +1800,8 @@ module Rigor
       # rows for `:always` assert directives (the slice-4a
       # routing places conditional asserts on `truthy_facts` /
       # `falsey_facts`, which `Narrowing.predicate_scopes`
-      # consumes). Future plugin contributions that add
-      # `:always` assertions at the same call site flow through
-      # the same merger and land here.
+      # consumes). Plugin `:always` assertions are handled by
+      # the sibling `apply_plugin_assertions`, not this path.
       def apply_rbs_extended_assertions(call_node, current_scope)
         method_def = resolve_call_method(call_node, current_scope)
         return current_scope if method_def.nil?
@@ -1770,16 +1867,9 @@ module Rigor
       EMPTY_CONTRIBUTIONS = [].freeze
       private_constant :EMPTY_CONTRIBUTIONS
 
-      # Per-dispatch collection of plugin narrowing contributions. Mirrors
-      # `MethodDispatcher#collect_plugin_contributions`: visit only the
-      # registry-ordered subset of plugins that implement a per-call path
-      # (`for_statement` = declares a `type_specifier`), gate each path
-      # by membership AND by the ADR-52 WD1 method-name gates (every
-      # `type_specifier` rule is `methods:`-gated, so the common
-      # no-candidate case is a single Set probe; a pruned
-      # consultation could only have returned `[]`), and accumulate
-      # lazily (shared frozen empty array otherwise). Same contributions in
-      # the same order as visiting every plugin; the caller is read-only.
+      # Fast-exit guard: skip if no plugin declares a `type_specifier`, or if
+      # no registered method-name gate matches the call. See
+      # `collect_gated_statement_contributions` for the full consultation.
       def collect_plugin_contributions(registry, call_node, current_scope)
         index = registry.contribution_index
         relevant = index.for_statement
@@ -1791,8 +1881,10 @@ module Rigor
         collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
       end
 
-      # The post-gate walk, in registry order — the same order the
-      # ungated walk used.
+      # ADR-37 slice 2 / ADR-52 WD1 — post-gate walk in registry order.
+      # Visits only plugins in `for_statement` (declare a `type_specifier`),
+      # further gated by the method-name Set probe so the common no-candidate
+      # case is a single lookup. Accumulates lazily; caller is read-only.
       def collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
         result = nil
         relevant.each do |plugin|
@@ -2677,6 +2769,12 @@ module Rigor
           source_path: scope.source_path
         )
         bindings = binder.bind(def_node)
+        # ADR-67 WD3 — override an undeclared parameter with its call-site
+        # inferred type (precision-additive; an RBS-declared parameter wins,
+        # the table is empty on a normal `check` run). The inferred type lives
+        # only as a body local, never as an RBS contract, so it cannot fire a
+        # parameter-boundary diagnostic (WD1, satisfied by construction).
+        bindings = seed_inferred_param_types(bindings, def_node, singleton)
 
         # Method bodies do NOT see the outer scope's locals. They start
         # from a fresh scope with the same environment, then receive
@@ -2690,9 +2788,47 @@ module Rigor
         fresh = seed_instance_ivars(fresh, singleton: singleton)
         fresh = seed_class_cvars(fresh)
         fresh = seed_program_globals(fresh)
+        # ADR-48 Struct slice 3 — install the method body's fold-safe-local set
+        # so a member read off a mutation-free local folds during the in-body
+        # walk (the call-return inference path is seeded separately).
+        fresh = fresh.with_struct_fold_safe(
+          StructFoldSafety.fold_safe_locals(
+            def_node.body, ->(name) { scope.struct_member_layout(name)&.[](:members) }
+          )
+        )
         bindings.reduce(fresh) { |acc, (name, type)| acc.with_local(name, type) }
       end
 
+      # ADR-67 WD3 — consult the call-site parameter-inference table for this
+      # `def` and replace each undeclared (untyped) parameter binding with its
+      # inferred type. Keyed by `[class_name, method_name, kind]`, reconstructed
+      # from the lexical class path — the same triple
+      # {Inference::ParameterInferenceCollector} records. An RBS-declared
+      # parameter (a non-untyped binding) always wins. No-op when the table is
+      # empty (the normal `check` path), so the seed is byte-identical there.
+      def seed_inferred_param_types(bindings, def_node, singleton)
+        inferred = scope.param_inferred_types
+        return bindings if inferred.empty?
+
+        path = current_class_path
+        return bindings if path.nil?
+
+        table = inferred[[path, def_node.name, singleton ? :singleton : :instance]]
+        return bindings if table.nil? || table.empty?
+
+        merged = bindings.dup
+        table.each do |name, type|
+          merged[name] = type if merged.key?(name) && untyped_binding?(merged[name])
+        end
+        merged
+      end
+
+      # True for the `Dynamic[Top]` carrier `MethodParameterBinder` leaves on an
+      # undeclared parameter — the only bindings ADR-67 WD3 overrides.
+      def untyped_binding?(type)
+        type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+      end
+
       def seed_instance_ivars(body_scope, singleton:)
         return body_scope if singleton
 
@@ -2783,7 +2919,7 @@ module Rigor
         when Prism::ConstantReadNode
           receiver.name.to_s == prefix.last
         when Prism::ConstantPathNode
-          rendered = render_constant_path(receiver)
+          rendered = Source::ConstantPath.render(receiver)
           return false unless rendered
 
           path = rendered.split("::")
@@ -2823,25 +2959,6 @@ module Rigor
         end
       end
 
-      def qualified_name_for(constant_path_node)
-        case constant_path_node
-        when Prism::ConstantReadNode
-          constant_path_node.name.to_s
-        when Prism::ConstantPathNode
-          render_constant_path(constant_path_node)
-        end
-      end
-
-      def render_constant_path(node)
-        prefix =
-          case node.parent
-          when Prism::ConstantReadNode then "#{node.parent.name}::"
-          when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
-          else ""
-          end
-        "#{prefix}#{node.name}"
-      end
-
       def singleton_context_for(node)
         case node.expression
         when Prism::SelfNode
@@ -2880,7 +2997,7 @@ module Rigor
         when Prism::ConstantReadNode
           expression.name.to_s
         when Prism::ConstantPathNode
-          render_constant_path(expression)
+          Source::ConstantPath.render(expression)
         end
       end
 
@@ -2914,6 +3031,19 @@ module Rigor
         [Type::Combinator.bot, scope]
       end
 
+      # A `break` transfers control to the loop exit (its flow value is `Bot`,
+      # like `return`). It records the current scope into the active loop's
+      # break sink so the loop join can recover a `break`-path binding the
+      # fall-through would drop (`flag = true; break` -> `flag` is `false |
+      # true` after the loop). nil sink = a `break` not inside an inferred
+      # loop body (a block targeting a method, or top-level) — left to the
+      # existing escaping-block / no-op handling.
+      def eval_break(node)
+        sink = Thread.current[BREAK_SINK_KEY]
+        sink << [node, scope] if sink
+        [Type::Combinator.bot, scope]
+      end
+
       def record_return_value(node, sink)
         args = node.arguments&.arguments || []
         # `return` with no argument returns nil; `return a` records the